58 Commits

Author SHA1 Message Date
twotalesanimation a3859aa61b feat(connector): build a QC review session for a whole project
Build QC Review Session (QC section) makes a QC_{shot}_{version} comp
for every shot in the project's QC queue. The export sits over its
earlier versions and plates, and only the export and the main plate are
switched on. Each scene also gets a continuous edit, cut to the edit
with the handles trimmed, and a contact sheet. QC Pass/Fail now act on
the shot comp in the viewer, the selected shot in a scene comp, or the
shot under the playhead in a scene edit, and label the result
green/red. The QC queue now also returns seqTimecodeStart, handleHead
and handleTail.

Compare Versions now lines versions up by EXR timecode, then by file
frame number. It used to use Export.frameStart, which is
timecode-anchored, not 1001-based.

Also includes Keep AEP (panel 2.9.0): Queue Export saves a reduced
.aep copy in each export's version folder.

Panel 2.10.0. Not yet run in After Effects.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-10 12:45:33 +02:00
twotalesanimation 4cbb5d341c feat(connector): compare QC exports with earlier versions
Compare Versions in the QC section opens the export's QC comp and stacks
earlier v### EXR sequences of the shot under it, one layer per version,
lined up by frame number. Finds versions next to the export in both
on-disk layouts (per-version folders and the older flat folder). Open
Render now names the export's layer by version. Panel 2.8.0.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-08 08:14:27 +02:00
twotalesanimation 06a4122ebb feat(shot-status): status badges filter the shot list
Deploy / deploy (push) Successful in 3m28s
Clicking a summary badge shows only shots with that status; several can be
combined. Selection drops shots the filter hides so bulk actions never reach
them. Filter resets on project change.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-08 03:46:43 +02:00
twotalesanimation 842a8fe036 feat(board): paste client feedback from WhatsApp
Deploy / deploy (push) Successful in 3m34s
"Paste feedback" on each board card takes a client's message as it arrived
and splits it into rounds ("FEEDBACK 113 DUE Oct 7 12:00 PM") and per-shot
notes, tolerating WhatsApp copy prefixes, bold markers, wrapped lines,
several codes per note and codes without the show prefix.

A review step shows each note's shot, the version the client was sent,
the player frame and a "move task to Changes" tick (on by default).
Saving creates a FeedbackRound, a player comment per note tagged
source=WHATSAPP (shown as "Client feedback") and a board line under the
round's due time; ticking the line off resolves the comment.

Quoted frames are read as comp frames: shot frameStart or the house 1001,
plus the slate (recorded, else 1 for pipeline previews). Version.duration
is never stored on live, so the length-based slate inference can't be used.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-07 17:31:34 +02:00
twotalesanimation 34af26dfbf feat(board): daily board linked to shots
A /board page that replaces the shared doc used as the day-to-day tracker.
One card per active/on-hold project with a status line, dated milestones
and to-do lines typed or pasted in the doc's own format:

  DH2_VFX_027_090 finalise (CHRIS)
  DH2_VFX_005_010 gfx update @michelle wait: client GFX ADH_GFX_005_020

Shot codes link to the shot (live status + latest version), (NAME)/@name
assigns, wait: marks a blocker, headings group lines. Codes that match no
shot are flagged, with a relink when there is an obvious near miss.

Board lines are their own model, not Tasks: tasks drive shot status and
notifications, and a note like "finalise" must not touch either.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-07 17:30:40 +02:00
twotalesanimation 27d9618995 feat(client-portal): group shots by scene
Deploy / deploy (push) Successful in 3m31s
Collapsible scene sub-headers inside each episode, in scene order with
per-scene status counts; the review queue follows the same order. Aliased
shots go out without a scene so our numbering never reaches the client.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 08:41:19 +02:00
twotalesanimation 1d60a55b3c fix(shot-status): compact last sent cell
Deploy / deploy (push) Successful in 3m28s
Recipient moves to the tooltip, the version and date no longer wrap, and the
column is narrower so Notes keeps its room.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-05 16:39:29 +02:00
twotalesanimation 88112112d4 feat(shot-status): last sent column per shot
Deploy / deploy (push) Successful in 3m27s
Shows what last reached the client with evidence (shared EXR package or
manual delivery), anything newer still on its way, and the last review MOV,
so it's clear on Shot Status what has actually been sent.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-05 16:24:18 +02:00
twotalesanimation 91e69f0bcb feat(worker): parallel multipart uploads for large artifacts
Deploy / deploy (push) Successful in 3m18s
From the studio a single connection to Hetzner nbg1 (188 ms away) is
capped near 0.1 MB/s, although a browser speed test shows 50 Mbps.
Measured: 1 connection 0.13 MB/s, 8 -> 0.64, 24 -> 1.69 MB/s. At the old
speed a ProRes MOV could not finish inside the 30 min request timeout.

- Worker 1.7.2 uploads files >= 16 MB as S3 multipart: 8 MB parts on
  uploadConcurrency connections (config.json, default 16), each part
  retried up to 4 times; aborts the upload if a part keeps failing.
- artifact-presign returns uploadId + per-part presigned URLs when asked
  for multipart; new E20b artifact-complete stitches or aborts.
- Old workers and old servers fall back to the single PUT.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-01 18:48:28 +02:00
twotalesanimation 477aef7b27 feat(worker): upload status in the job log, ProRes uploaded in the background
Deploy / deploy (push) Successful in 3m25s
Preview jobs looked stuck after aerender finished: the worker was silently
uploading the review MP4s and the ProRes MOV over a slow uplink, and a
restart mid-upload threw the preview away.

- Worker 1.7.1 replaces the job's log tail with live upload status and logs
  each upload's size, duration and speed.
- The ProRes MOV now uploads after finalize via a persistent queue
  (HighResUploader, resumes after restart, 5 attempts) and attaches through
  the new E13b endpoint POST /api/ext/render/jobs/{id}/attach-highres.
  A MOV from a superseded preview is discarded.

Deploy the server before the 1.7.1 worker.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-01 18:13:23 +02:00
twotalesanimation f30acef101 feat(deliveries): delivery requests and upload/share evidence
Deploy / deploy (push) Successful in 5m17s
A built package used to become DELIVERED on one click with nothing behind
it, and nothing recorded what a client had asked for.

- Marking delivered is now two recorded steps: Record upload (the link on
  the client's portal, contents confirmed) then Share link (who it was sent
  to). The second is refused until the first is on record.
- Delivery requests log a client's ask by episode, pasted shot codes or a
  Shot Status selection. A line closes only when its shot goes out with
  evidence after the request was logged; a request can otherwise only be
  cancelled with a reason.
- Delivered Outside Pipeline takes an upload link and recipient, required
  for shots on an open request.
- The dashboard gains an Awaiting delivery section listing open requests
  and built packages the client does not have yet.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 14:21:24 +02:00
twotalesanimation 326d8cbefa fix(playlist): black screen in production builds
Deploy / deploy (push) Failing after 1m25s
On mount, the loop-toggle effect preloaded clip 2 into the slot the first
goTo was loading clip 1 into, cancelling it, so nothing ever went on screen.
Dev's StrictMode double-mount re-ran the first load and hid it.

- preloadNext never loads over a slot a goTo is loading into
- the loop effect only reloads the standby on an actual toggle
- pausing or jumping mid pre-roll no longer re-parks a clip that a jump
  has since put on screen

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-26 11:54:02 +02:00
twotalesanimation b596c97faf feat(playlist): seamless playback of selected shots, cut only
Deploy / deploy (push) Successful in 3m12s
Check shots on the Playlist page and "Play selection" plays them back to
back without slate or handles. The cut comes from the version's handle and
slate metadata (new cutSpan in lib/handles); the media is never changed.

SequencePlayer double-buffers two videos: the next clip is parked a few
frames before its cut-in and pre-rolled hidden, the outgoing clip pauses on
its last cut frame, and the cut fires on the incoming clip's cut-in frame
(requestVideoFrameCallback), with the start time calibrated at each cut.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-26 08:55:46 +02:00
twotalesanimation 824695ef30 feat(clients): reactivate an expired client review link
Deploy / deploy (push) Successful in 3m16s
Expired links on the client page get a Reactivate button (7-90 days).
PATCH /api/review-sessions pushes the expiry out and turns the link back
on with the same token, so the URL the client already has works again.
Staff roles only, as for creating a link.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-25 05:38:42 +02:00
twotalesanimation 390d7a21ac feat(connector): move Increment Shot Version into the Render Pipeline panel
The button sits beside Regenerate Previews instead of at the bottom of
Actions. Panel bumped to 2.7.1.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-25 05:38:41 +02:00
twotalesanimation 5e29c3b88d feat(pipeline): search the render queue by shot or client code
Deploy / deploy (push) Successful in 3m16s
A search box above the exports table matches any part of the shot code or
client code, case-insensitively, so "UNG_114" lists a whole episode. It is
applied server-side (the table is paged there), debounced, and scopes the
summary counts too; combines with the project and status filters.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-25 04:51:04 +02:00
twotalesanimation c2509512ff feat(delivery): record shots delivered outside the render pipeline
Deploy / deploy (push) Successful in 3m34s
Shots delivered by hand before the pipeline have no Export, so they could
never appear in a DeliveryPackage and the dashboard countdown showed them
as not delivered. Add Shot.manualDeliveredAt/ById/Note, a "Delivered
Outside Pipeline" bulk action on Shot Status (mark with the real date, or
clear), a badge on marked shots, and count them in the countdown alongside
DELIVERED EXR packages. The real date keeps the weekly rate honest.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-25 04:03:56 +02:00
twotalesanimation 27f9f7ac64 fix(api): shot API 500 once a version has a ProRes size
Deploy / deploy (push) Successful in 3m16s
Version.highResSize (added in 9660cdc) is a BigInt, and GET
/api/shots/[shotId] spreads whole version rows into NextResponse.json,
converting only fileSize. As soon as worker 1.7.0 finalized an export
with a ProRes upload, JSON.stringify threw "Do not know how to serialize
a BigInt" and the shot page failed to load.

- Convert highResSize alongside fileSize in that route.
- lib/db.ts: serialize any BigInt as a string in JSON (BigInt.prototype
  .toJSON), so other routes returning whole rows can't 500 the same way.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-22 17:23:03 +02:00
twotalesanimation 9660cdc21c 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>
2026-09-22 16:32:18 +02:00
twotalesanimation bae46c2968 chore(connector): bump panel to 2.7.0 for the Includes handles option
Deploy / deploy (push) Successful in 3m17s
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-22 15:33:24 +02:00
twotalesanimation 2e9fa45580 feat(review): flag handles in the review player (metadata only)
Deploy / deploy (push) Successful in 3m31s
Renders run 8 frames past the cut at each end. Directors were flagging
glitches in unfixed handles as shot problems, so the player now marks
them — without trimming or burning anything into the EXRs/MOV/MP4.

- Version.handleHead/handleTail/pictureStartFrame, Export.handleHead/
  handleTail; migration backfills pipeline exports and their preview
  versions from the manifest's handleFrames (else 8)
- AE panel: "Includes handles [8] frames each end" -> manifest.review;
  older manifests fall back to source.handleFrames
- finalize copies handles onto the Version; worker 1.6.4 reports the
  head slate length (pictureStartSeconds), else the player infers it
  as MP4 frames - EXR frameCount
- Player: hatched HANDLE / SLATE regions and cut marks on the timeline,
  "HEAD/TAIL HANDLE · NOT IN EDIT" overlay on handle frames, HANDLE badge
  on notes, "Edit range only" toggle (default on in the client portal)
- Staff Handles editor on the review page for manual uploads/corrections

Also fixes two player bugs found while testing: timeToFrame floored
float error (every seek landed a frame early), and J/reverse never ran
(the keyboard effect's cleanup stopped it on the next render).

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-22 15:07:29 +02:00
twotalesanimation 2817c7e815 fix(annotations): lock annotations to the picture at any player size
Deploy / deploy (push) Successful in 3m7s
Points were normalised to the whole player box, but the video is drawn
object-contain inside it, so any change in the player's shape (window or
panel resize, fullscreen, phone rotation, the annotation toolbar opening)
moved the picture under the marks.

The canvas now sits exactly over the displayed picture (same letterbox
measurement as AspectOverlay), so points are fractions of the image and
new saves are tagged version "2.0". Legacy "1.0" annotations are mapped
onto the picture at load time from their stored canvasWidth/canvasHeight
and the video's intrinsic size; no data migration. The save action now
accepts both versions.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-22 14:34:57 +02:00
twotalesanimation 428814b8b9 feat(review): zoom and pan in the review player
Deploy / deploy (push) Successful in 3m16s
Wheel / trackpad pinch zooms toward the cursor (up to 8x), drag pans when
zoomed, and two-finger pinch works on phones. A drag never toggles
playback. A badge shows the zoom level with -/+/Fit while zoomed, and
+ / - / 0 work from the keyboard. Zoom resets when the video changes.

Video, blanking and the annotation canvas zoom as one layer, so marks
drawn while zoomed land where the pointer is and stay pinned to the image.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-22 14:25:46 +02:00
twotalesanimation 45459e4b12 fix(review): Share with Client in the player shares the shot
Deploy / deploy (push) Successful in 4m14s
The review player's button only made the viewed version client-visible. It
never set shot.sharedWithClient, and the client portal lists only shared
shots (and only each task's latest version), so the button reported
"Shared with Client" while the client saw nothing. It also skipped the
internal approval the shot page requires.

For a version that belongs to a shot (directly or through its task), the
button now runs the shot page's shareWithClient: shot marked shared, latest
version of each task visible, status to Client Review. It is disabled with
an explanation until the shot is internally approved, and the player's
Approve Internally button now appears for task versions too, only while the
shot awaits approval. Asset versions keep the per-version share.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-18 09:24:42 +02:00
twotalesanimation 2b373737d8 feat(review): review players usable on phones
Deploy / deploy (push) Successful in 3m11s
Internal review: the comments panel stayed a 320px sidebar on phones,
leaving the video a 55px strip. Below md it now sits under the video
(collapsible, arrow pointing down/up), and the top bar puts shot + version
on one row with the share and approval actions on a second.

Client review: the header's three-column grid overlapped on phones
(Approve drawn over the shot code). Below md it is two rows: back, shot and
prev/next, then status and the decision buttons. The status badge now shows
on phones, and the notes toggle points down/up to match its position.

Desktop is unchanged on both.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-18 08:13:14 +02:00
twotalesanimation 724b0cbefe fix(shot-status): Group by buttons fit on phones
The project picker (fixed 288px) and the Group by buttons shared one
unwrapping row, so on a phone the buttons ran off the right edge. Below md
the picker fills the row and Group by wraps onto its own line; from md it
is one row as before.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-18 08:13:13 +02:00
twotalesanimation 0c4f94d56a feat(client-portal): readable shot list on phones
Deploy / deploy (push) Successful in 3m14s
On a phone the approval badge was drawn over the version name on every row,
the TWO TALES logo broke over two lines, and in "recent" sort the date
wrapped onto three. Below sm the version name now takes its own line with
the badge under it, the logo stays on one line and a long link label is
truncated, and the date no longer wraps. Hover-only copy buttons are hidden
on phones, where they were invisible but still took space.

Desktop is unchanged.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-18 07:01:05 +02:00
twotalesanimation 40b99f3add feat(ui): usable on phones without changing the desktop layout
Deploy / deploy (push) Successful in 3m19s
At phone width the sidebar stayed 240px wide, leaving pages a ~135px strip.
Below md it is now hidden behind a menu button in the header and opens as a
drawer (closes on navigation, backdrop, X or Escape); from md up the sidebar
is unchanged. Page wrappers use p-4 on phones and keep p-6/p-8 from md.

Shot detail: on phones the thumbnail takes the full width with the details
below it instead of pushing them off screen, the action buttons wrap, and
the tab bar scrolls sideways. Desktop sizing is kept as it was.

Every change is behind a md: breakpoint, so the desktop layout is the same.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-18 06:56:38 +02:00
twotalesanimation 33bc6a935c feat(ui): shot status, projects and client portal keep their place
Deploy / deploy (push) Successful in 3m31s
Coming back from a shot left the shot status page at the top with its
sections reset. The scroll restore saved window.scrollY, but dashboard pages
scroll the layout's <main>, so it always saved 0; the Projects page had the
same bug. Only episode expansion was remembered — scene and group sections
came back fully collapsed.

A shared useScrollMemory hook saves the real scroll container's position as
the user scrolls (so any way of leaving keeps it) and restores it once the
content that sets the page height is back. It ignores the scroll the shared
<main> fires when the next page replaces this one, which otherwise
overwrote the saved position.

Shot status now remembers episode, scene and group expansion per project.
The client portal already kept its filters and collapsed episodes but
restored scroll before they were applied; it now uses the hook too.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-18 05:52:13 +02:00
twotalesanimation 532ebd82d7 feat(pipeline): tabbed render queue with paged exports
Deploy / deploy (push) Successful in 3m32s
The queue page loaded up to 200 exports in one table with the Blender
renders appended underneath, so a Blender job sat below the whole export
history. Exports and Blender renders are now separate tabs; the Blender tab
label shows how many are active or failed so a render stays visible from
the exports tab.

Exports page 25 at a time. The summary cards now come from a server-side
count per status (listExports.statusCounts) instead of counting the loaded
rows, which was already wrong past 200, and clicking a card filters to it.
The project filter moves to the header since it applies to both tabs, and
the duplicated Deliveries button is gone.

Adds .claude/launch.json for running the dev server from the preview pane.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-18 05:04:41 +02:00
twotalesanimation 708e8a0d8f fix(worker): parse Blender 5.x output so rendered frames are counted
Deploy / deploy (push) Successful in 3m28s
Blender 5 logs through CLOG, prefixing every line with elapsed time and a
category ("00:02.954  render | Saved: '...'"), and reports errors as
"ERROR ..." instead of "Error: ...". The parser anchored on "Saved:" at the
start of the line, so it counted no frames from a render that wrote all of
them and the job failed as "saved no frames". Progress (Fra:) and error
detection were dead on 5.x for the same reason.

The prefix is now stripped before matching; 4.x output parses as before.
Warnings no longer count as errors: add-ons print them on every launch and
one would otherwise be reported as the reason a render failed. A run that
saves nothing now reports Blender's own error when there is one.

Verified on the real DH2 test.blend under Blender 5.2: the 1.6.2 parser
counts 0 of 3 saved frames, this one counts 3.

Bump worker to 1.6.3.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-18 04:42:33 +02:00
twotalesanimation 97246bcbc3 fix(worker): Blender jobs always failed with "Collection was modified"
LogTail was read by the progress loop while the output pumps appended to
it. Blender rewrites its status line many times a second, so the first
progress report of every job threw; aerender hit the same race only rarely.
LogTail now locks internally.

The exception also escaped BlenderRunner without ending the process, leaving
blender.exe rendering unsupervised on the node on every failed attempt. Any
unexpected exception in the monitor loop now kills the process tree.

Bump worker to 1.6.2.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-18 04:21:54 +02:00
twotalesanimation 400cf3f6ea feat(validation): try the comp's other delivered plates before failing timecode
When the timing plate disagrees with the render, the worker now checks the
manifest's other plates[] that sit under a plate search root (or beside the
timing plate's footage folder). A match is a PASS naming that element; no
match still FAILs against the timing plate, listing the alternates tried.
Pre-renders are excluded because they agree with the render by construction.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-18 04:21:53 +02:00
twotalesanimation 2dee1bf6fc feat(batch-upload): bulk footage plate upload matched by filename
Deploy / deploy (push) Successful in 6m39s
Adds a third section to the Batch Upload page that attaches plate movies to
shots derived from the filename: DH2_VFX_058_120_REF.mov becomes the plate
"REF" on shot DH2_VFX_058_120. Shot matching reuses findMatchingShotCode, so
it behaves like the rest of the page (case-insensitive, longest code wins,
underscore-boundary only) and the filename remainder becomes the label.

Bytes go straight to Hetzner via the existing presign endpoint since plates
are multi-GB, with XHR for per-file progress. Files whose shot already has a
plate of the same name are skipped so re-running a batch does not stack
duplicates.

Also resets the thumbnail and plate previews when the project changes — they
are resolved against a specific project, but only the version-upload flow was
being cleared.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-12 12:15:29 +02:00
twotalesanimation 469d782b4f feat(projects): poster art and equal-height project cards
Deploy / deploy (push) Successful in 6m27s
A grid of twenty projects was twenty near-identical blocks of text. The cards
now lead with a still, with the code, client and title set over it.

There is no poster column on Project and adding one would mean somebody
maintaining it, so the image is chosen from the shots the project already has:
a key shot with a still first, then the most recently touched shot with one.
Within each, thumbnailUrl beats generatedThumbnailUrl - the same precedence
the rest of the app displays shots by, since the reference frame from the
brief is a deliberate choice and a promoted render frame is whatever the
pipeline landed on. The pick is deterministic rather than random: a card whose
image changes between two loads reads as a glitch, and the eye stops using the
image to find the project.

One DISTINCT ON query covers every project on the page, instead of a query
each or dragging back every shot that has a still.

Equal heights come from three things: auto-rows-fr on the grid, h-full on the
card, and fixed room for the description, which was the only part that varied.
A project with no stills gets a placeholder of the same footprint rather than
a hole in the row. The whole card is now the link, so the Open button is gone.

Also fixes a latent bug: the card read project.deadline, but the column is
dueDate, so the due date never rendered. Both are accepted now.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-10 07:36:04 +02:00
twotalesanimation 6afbe82a29 feat(dashboard): QC queue, deliveries and whose-court panels
Deploy / deploy (push) Successful in 6m51s
Completes the operations dashboard.

QC queue: what is waiting on a person to watch the frames, oldest first.
Every stage before QC is worked by the farm, so this is the only one that
cannot drain itself - depth here is the best early warning that a delivery
date is going to move, and it had no home outside a filter on the queue page.

Deliveries: the last few packages, flagging FAILED and builds stuck in
BUILDING. A failed build is otherwise silent - the exports stay
READY_FOR_DELIVERY, nothing reaches the delivery volume, and nobody finds out
until the client asks where the shots are.

Whose court: versions sent to the client and unanswered, against shots with
unresolved notes. Two numbers rather than one because they call for opposite
responses - a fortnight-old review is a phone call, unactioned notes are a
scheduling problem.

The artist view now scopes to the artist throughout: the blocked list, and
the counters above it, which otherwise quoted a studio-wide figure next to a
personal list.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-10 05:58:08 +02:00
twotalesanimation 6bfc013e35 feat(dashboard): episode delivery countdown
Turns "23 shots to go" into "you are not going to make it". One card per
episode from EpisodeDueDate (or the project's own date on a standard show):
days left, the episode's shots by where they actually are, and the only
comparison that matters - shots per day still needed against shots per day
the studio managed over the last week.

A shot counts as delivered when it appears in a DeliveryItem inside a
DELIVERED EXR_DELIVERY package. Shot.status is deliberately not the measure:
it says where the work is, not whether the client has the frames, and a
MOV_REVIEW package ships nothing.

The pace arithmetic is a pure function so the sentence a producer acts on is
testable: a rate that only just lands on the due date reports as "no slack"
rather than fine, and a week with no deliveries reports as stalled instead of
projecting infinity.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-10 05:45:01 +02:00
twotalesanimation f6a7f0ef5a feat(dashboard): show what is blocked and how the farm is doing
The dashboard was a generic task-manager view of a studio that does not work
that way. Two of its five headline numbers counted Task.dueDate, which no
pipeline code writes - the only writer is a manual field on the task detail
page, so those cards read zero by construction. The rest were unscoped and
cumulative ("approved" across every project ever finished), the activity feed
was the notification table, and the shot queue sampled 15 rows by updatedAt,
a column the farm touches constantly. Nothing about failed exports, QC depth
or the render farm appeared at all, so a RENDER_FAILED was only visible if
someone thought to open the queue and filter for it.

Replaced with pipeline state, which the system maintains on its own:

- Blocked queue: the four failed statuses plus exports that stopped
  progressing, each with the reason read off the actual cause - the failing
  validation check, the QC note, the aerender error, or the machine that
  claimed it and went quiet.
- Farm strip: machines, queue depth by job type, oldest unclaimed job, and
  worker-version drift, since a worker's version decides which fixes it has.
- Five counters that can go down, scoped to live productions, each linking to
  the rows it counted.

The queue page ignored ?status=, so the counters had nowhere to link; it now
takes an initial filter from the URL. Stat cards are hidden from CLIENT users
- the old ones were generic version counts, these are internal pipeline state.

Thresholds live in SystemConfig (dashboard.qcStaleHours, .stalledJobHours) so
they can be tuned without a redeploy.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-10 05:40:40 +02:00
twotalesanimation fe420b9455 chore(worker): bump to 1.6.1 for the PrepareOutputDir fix
Deploy / deploy (push) Successful in 6m49s
The version is what a machine reports on startup, so it has to move for the
Machines page to show which nodes are still clearing the preview MOV out of
the version folder.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-09 07:06:37 +02:00
twotalesanimation 2a8888089f fix(worker): stop PrepareOutputDir deleting the version's preview MOV/MP4
Deploy / deploy (push) Successful in 6m33s
PrepareOutputDir cleared every file in the output dir whose name started
with the output pattern's prefix. The preview stage writes its MOV and MP4
into that same folder from the same basename ({outputDir}/{base}.mov), so
they matched the prefix and were deleted before aerender started.

The dir is not private to one export: outputDir is keyed on the shot's
manually-set shotVersion, not on the export, so re-queuing without a
Version Up renders into the folder again. That is exactly the "No preview"
workflow - export scaled, reverse the scale, re-render only the EXRs and
inherit the earlier MOV - and inheritPreviewMedia then handed the new
export a deliveryMovPath pointing at the file the render had just removed.
Nothing surfaced it: the review MP4 is an uploaded blob and still played,
and DeliveryStage treats a missing MOV as non-fatal, so the package
silently shipped EXRs with no viewing copy.

Match on prefix and extension instead, via a new
SequencePattern.MatchesOutputFile - the predicate ValidationStage and
DeliveryStage already applied inline. Crashed-attempt cleanup is unchanged;
only files with a different extension are now spared.

JobExecutor's post-render stats loop matched on prefix alone too. With the
media no longer deleted it would have counted the MOV/MP4 as frames and
failed validation's file_count check, so it uses the same matcher.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-08 23:19:33 +02:00
twotalesanimation a073f92da3 fix(delivery): number same-day packages per episode, not per project
Deploy / deploy (push) Successful in 7m31s
Numbering was scoped to the project, so the day's first delivery of
episode 102 was named _02 purely because episode 101 had already gone out
that morning. The count is meant to distinguish repeat deliveries of the
same content, and packageDir already separates episodes — three episodes
delivering today each land in their own folder and each are that folder's
first delivery. Adding `episode` to the lookup makes the suffix mean what
the folder layout already implies: only a second delivery of the *same*
episode becomes _02. The [projectId, episode] index already exists, so
the extra filter costs nothing.

packageNameTemplate also moves from {yymmdd} to {yyyymmdd}. The AE panel
has always built its local delivery folders with a four-digit year, so
this is the server matching the connector rather than a new convention.
The {yymmdd} token stays in TokenValues: a project carrying its own
template in deliveryConfig is unaffected either way.

Existing packages are untouched — buildDeliveryJobManifest reads rootPath
off the record. On the day of the changeover an episode that already
delivered as 260903_Delivery starts again at the bare 20260903_Delivery,
which is a different name and a different folder, so nothing merges.

Producer reviews keep their per-project numbering: a review can span
several episodes and stores episode as "", so scoping it the same way
would put every such review in one bucket.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-03 10:07:52 +02:00
twotalesanimation 04e5eb123a feat(shot-status): bulk-assign selected shots to an artist
Deploy / deploy (push) Successful in 6m30s
Adds an "Assign Artist" entry to the bulk actions menu, backed by a
bulkAssignArtist server action. The action re-checks the target user
server-side — a deactivated account or a CLIENT is rejected rather than
trusted from the picker — and passing null clears the assignment, so
reassignment and hand-back are the same flow.

Like single-shot assignment in updateShot this writes the column and
sends no notification, so reshuffling a batch during planning stays quiet.

Also renders the Artist column the page was already querying but never
showing; without it there was no way to see the result of an assignment.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-03 09:51:13 +02:00
twotalesanimation 75f9258b69 feat(player): aspect-ratio blanking overlay in the review player
Deploy / deploy (push) Successful in 5m39s
A shot is reviewed at the framing it was rendered at but usually delivered
cropped, so add a dropdown beside the playback-speed control that lays
delivery blanking over the video: 2.39 through 9:16, widest to tallest, with
"No blanking" as the default. Purely a viewing aid — nothing is written to
the review, and the video element is untouched.

The geometry is the awkward part. The video is object-contain, so the picture
is letterboxed inside the element and bars drawn against the element's edges
would be wrong on any panel whose shape does not match the source.
letterboxRect works out where the picture is actually painted and the bars are
positioned against that, kept current by a ResizeObserver and a loadedmetadata
listener so resizes and fullscreen stay correct. Ratios within half a pixel of
the source draw nothing rather than a hairline of rounding error.

Two modes, since blanking and crop bars are different jobs: solid black hides
the crop the way the master will, guide dims it so the excluded area is still
readable. The overlay sits under the annotation canvas — deliberately no
z-index, since the canvas sets none either and DOM order alone gives marks
drawn over a blanked area the right precedence.

Verified against real browser layout, not just unit tests: the computed
picture rect lands exactly on the image edges across three panel shapes, and
the visible area measures the requested ratio.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-02 07:21:58 +02:00
twotalesanimation 269a5cbfda fix(delivery): separate packages by show, and number same-day deliveries
Deploy / deploy (push) Successful in 6m27s
Two faults in how a package's folder is named, both of which put unrelated
files in one directory on the delivery volume.

The default layout had no {showId}, so every show's episode 101 resolved to
{deliveryRoot}/101/{packageName}. The token existed and was populated — it
just never appeared in the path. With hardlinked packages that means two
shows delivering the same episode number on the same day write into the same
folder, and identically named shots overwrite each other. reviewDir had the
same hole, and is worse there: reviewNameFor scopes its lookup by projectId,
so a second show computes the bare base name and lands on the first show's
folder instead of suffixing past it.

createDeliveryPackage also never checked for an existing package of the same
name. packageNameTemplate is date-only and packageNumber is a per-project
counter that is not in the template, so a second delivery on the same day got
an identical name and rootPath and built on top of the first. MOV reviews
already did this correctly, so nextReviewName moves to deliveries.ts as
nextPackageName and both paths share it; the review-side name is kept as an
alias because it reads better at that call site.

Putting {showId} ahead of {episode} exposes an empty segment on non-episodic
shows, so paths go through tidyPath, which collapses it and leaves the UNC
root alone.

Historic packages are unaffected: buildDeliveryJobManifest reads rootPath and
configSnapshot off the record, so only new packages use the new layout. A
project with its own deliveryConfig.layout in the database still overrides
these defaults.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-01 08:08:37 +02:00
twotalesanimation 59af7959e6 fix(connector): request the full QC queue instead of the default 50
Deploy / deploy (push) Successful in 6m41s
loadQCQueue called /api/ext/qc/queue with no limit, so it always got the
endpoint's default page of 50. The query orders oldest-first, so a project
with more than 50 exports in READY_FOR_QC showed only the oldest 50 with
nothing to say the list was short.

Ask for 200 — the server's hard ceiling in getQCQueue — and say so in the
status line when the count comes back at the cap, so a truncated queue is
visible rather than silent.

The diagnostics call in checkServerPathReachable stays on the default: it
only reads entries[0].

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-01 07:24:21 +02:00
twotalesanimation a6ee1917e7 fix(connector): cancel the export poll when the panel closes or reloads
Deploy / deploy (push) Successful in 6m46s
app.scheduleTask outlives the panel instance that armed it. The repeating task
id was held in the pipelineState closure, so closing or reloading the panel took
the id with it and left nothing able to cancel the task: it kept firing every
15 s for the rest of the AE session, and every tick landing while a modal dialog
was open raised "Cannot run a script while a modal dialog is waiting for
response."

The id now lives in global scope beside the tick function that scheduleTask
already evaluates there, so the next panel instance can still reach it.
getPollTaskId and setPollTaskId wrap the access and treat anything that is not a
positive number as no task. Panel startup cancels whatever a previous instance
left armed before pointing the tick at itself, rather than letting the old task
fire into a fresh, empty state whose shot code went with the closure that armed
it, and panel.onClose stops the poll on the way out.

The export is unaffected either way: it runs on the farm, and the header picks
its status back up from the server on the next Refresh. Section 12.1 of
RenderPipeline2.md records that.

PANEL_VERSION goes to 2.6.1 per the documented rule, so Pipeline → Machines does
not show two workstations on one version behaving differently.

This change was authored in the working tree, not by Claude; it is committed
here alongside the status and client-portal work at the author's request, and
the message was written from reading the diff. It has not been exercised in a
live After Effects session as part of this commit.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-31 18:18:08 +02:00
twotalesanimation 28e8c47907 feat(client-portal): let a reviewer edit and delete their own notes
Notes left through a review link were write-once. A client who mistyped a
timecode or changed their mind had no way to correct it and had to add a second
note contradicting the first, which the studio then had to reconcile by hand.

PATCH and DELETE on comment/[commentId] cover both. Only the reviewer's own
notes are touchable: the studio's comments and those of every other review
session are read-only through a link, whatever the holder sends. Ownership is
re-checked server-side on every write, so the canEdit flag now returned by the
versions route only decides whether to offer the controls and grants nothing.

Refusals are 404 rather than 403 throughout, since a link holder has no business
learning which comment ids exist outside their own notes.

Only the text is editable. The frame a note is pinned to is what the studio
works from, so moving it would silently repoint feedback someone may already
have actioned; a note about a different frame is a new note. Deleting a drawing
note also removes its strokes, mirroring deleteComment in actions/comments.ts,
and the page reloads the player afterwards so the frame does not keep showing
marks that no longer exist. Delete goes through a confirmation that shows the
note and says plainly that it disappears for the studio too.

Worth knowing before this reaches a show: everyone holding the same review link
is the same author. A ReviewSession with no email resolves to a token-derived
guest user, so one link sent to three people gives all three one identity and
any of them can now edit or delete the others' notes. That model is not new,
which is why their comments already showed as one name, but edit and delete is
the first feature where it grants real power rather than muddling attribution.
Per-reviewer links with email set are the fix if that is not wanted, and that is
a change to how links are issued rather than to this code. The scope is
documented on reviewClientEmail so the next reader meets it before it surprises
them.

getOrCreateClientUser was copy-pasted into the comment and approve routes with
the fallback-email expression spelled out in three places. It is one set of
helpers in review-auth.ts now, including findReviewUser, a read-only variant so
that merely opening a review link does not conjure a User row just to answer
"is this theirs?", and ownsComment, the single rule shared by the route that
offers the controls and the route that enforces them.

Nine tests cover that rule directly: internal users' notes stay read-only, a
session that has never posted owns nothing, and an authorless comment — one
whose User was deleted, since Comment.authorId is SetNull — cannot be claimed by
anyone. The routes themselves are not covered, so exercise edit and delete
against a real review link before handing one to a client.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-31 18:17:40 +02:00
twotalesanimation 94792279c5 fix(status): reset review state on a new version, and derive shot status everywhere
Requesting changes on a shot and then re-rendering it through the render queue
left every layer of the app still showing the old verdict. Three independent
causes, all on the pipeline path.

finalizePreview inherited the superseded version's approvalStatus
unconditionally. The carry-over exists so a re-export of a signed-off shot does
not reappear as awaiting review, but it applied equally to NEEDS_CHANGES and
REJECTED, so the render queued to address a note arrived already wearing that
note and nothing registered that the work had been redone. carryApproval now
carries only APPROVED.

The pipeline never moved the task. One left on CHANGES by a review or a QC fail
stayed there through every re-render, with no way out but a manual kanban drag.
A genuinely new version now moves it to INTERNAL_REVIEW, as actions/versions.ts
and batch-upload already did. A replaced version is excluded: regeneratePreview
re-delivers the same version after a slate fix and is not a new submission.

The pipeline never called recalcShotStatus at all, so shot boards went stale the
moment a render changed a task. finalizePreview and the QC fail path both
recalculate now; the latter already documented the REVISIONS derivation it was
relying on and never triggering.

Shot.status is derived from tasks and approval flags, but six call sites wrote
it directly with the status they expected: internallyApproveShot,
shareWithClient, unshareFromClient, clientApproveShot, unapproveShot and the
client approve route. Rule 1 of the derivation is that any CHANGES task outranks
an approval, so a shot could be pushed past open rework and then snap back to
REVISIONS on the next unrelated recalc, which is close to unreportable as a bug.
They now set the approval inputs and let recalcShotStatus derive.
unshareFromClient additionally hardcoded READY_FOR_CLIENT even for a
client-approved shot. updateShotStatus keeps its direct write as the deliberate
manual override, now documented as transient for the same reason.

markShotForRevisions replaces the duplicated change-request logic. Both copies
marked all non-DONE tasks CHANGES, which matches nothing on the shot this is
most often called for: one out for client review precisely because all its tasks
are finished. The request then derived to INTERNAL_REVIEW and had no visible
effect anywhere. When nothing is picked up it now reopens the task behind the
shot's latest version, which is the deliverable the reviewer was looking at.

A client's shot-level change request also marks the versions and writes Approval
rows now. The dashboard counters, the version badges and the portal's own
filters all read Version.approvalStatus, so a shot-level verdict was invisible
everywhere those look.

clearStaleShotApproval covers the reverse case: uploading a new version onto an
approved shot moved the task to INTERNAL_REVIEW and changed nothing visible,
because the derivation short-circuits on shotApprovalStatus. The shot kept
reading COMPLETE while carrying work nobody had looked at. This is the one
user-visible behaviour change here, so watch the boards on a live show: an
approved shot now drops back to INTERNAL_REVIEW on a new upload. sharedWithClient
is deliberately left alone, since revoking client access stays a separate act.

submitApproval and unapproveVersion are transactional now. The verdict, the
version, the task and the derived shot status are one decision, and a failure
partway through left the three layers disagreeing with no way to tell which one
was right.

KanbanCard compared approvalStatus against "CHANGES_REQUESTED", which is not a
member of the enum, so the changes-requested icon never rendered at all.

Thirteen tests cover carryApproval, markShotForRevisions including the all-DONE
regression, and clearStaleShotApproval. What is not covered is the pipeline
transaction itself, which needs a database: queue a render against a shot in
REVISIONS and confirm the task and shot both move before trusting this on a
show.

Version.reviewStatus is still written nowhere while being published through
ext/shots/lookup and EXT_API_REFERENCE.md as a permanent "PENDING". Left alone
deliberately: removing a field from that contract could break the connector.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-31 18:17:04 +02:00
twotalesanimation 93137cdcd2 fix(connector): anchor built comps on the plate's own EXR timecode
Build Shot produced comps starting at 00:00:00:00 because the panel never
actually read the EXR timecode. getFootageStartFrames ranked a fragile "New
Comp from Selection" probe first: it toggles the Project panel via the Window
menu to get focus, and where that does not land the menu item is greyed out,
executeCommand silently does nothing, and the probe returns null. A shot with
no timecodeStart then fell through the API rank to zero.

The worker already reads EXR headers properly in ExrHeader.cs, and its
validation ranks the plate's own timeCode above the API value, which stores the
editorial in-point and sits a handle-length ahead of the plate by design. Shots
were therefore being built from rank 3 and validated against rank 1. That is a
timecode desync waiting to reach a delivery, not just a cosmetic start frame.

readExrTimecode ports the worker's reader to ExtendScript and becomes rank 1:
one short header read, walking `name\0 type\0 int32 size data` for timeCode and
falling back to timeCodeString where a writer omitted the packed attribute.
decodePackedTimecode mirrors Timecode.FromPacked, decoding the SMPTE 12M BCD a
byte at a time so the arithmetic never touches the sign bit. The menu probe is
kept as rank 2 and now runs only when the plate carries no timecode at all, so
the Project-panel toggle is off the normal path.

setCompStartFrame was the second failure. Assigning displayStartFrame on a
version of AE that does not have the property is ignored silently rather than
throwing, so the early return skipped the displayStartTime fallback entirely.
It now reads the value back, falls through when it did not take, and returns
whether anything stuck; buildShotFromCode logs when nothing does. A start frame
that cannot be set is now visible in the diagnostics report instead of a comp
quietly sitting at zero.

A plate whose timecode is present but zero still falls through to the API rank,
keeping the existing frames > 0 convention so the safety net survives. If a
genuine 00:00:00:00 plate should win outright that is a deliberate follow-up.

The parser is covered against synthetic headers, including the 0x18585712
example documented in ExrHeader.cs, drop-frame, truncated and non-EXR input.
What is not yet exercised in a live After Effects session is mainSource.file
resolving to the sequence's first frame and displayStartFrame taking on a given
AE build, so build one shot and check its start against the plate before
relying on this. Picture-lock automation was reverted for a timecode desync of
the same shape.

PANEL_VERSION goes to 2.6.0 per the documented rule, so Pipeline → Machines
does not show two workstations on one version behaving differently. The
startSource comment in the manifest schema enumerated only the two older
values; the queue-time provenance check keys on /\bAPI\b/ and so already reads
"EXR timecode …" as trustworthy rather than suspect.

The same silent-failure setCompStartFrame still exists in the farm-side
vfxr_build_preview.jsx, which is fed the right value from the manifest but can
drop it the same way. Left for its own change.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-29 16:53:49 +02:00
twotalesanimation 6678721fb1 fix(pipeline): create the comp task an export needs when a shot has none
Deploy / deploy (push) Successful in 6m48s
A shot with no COMP task rendered and previewed fine and then showed
nothing in the app. createExport set Export.taskId from the shot's first
COMP task or null, and finalizePreview registered the review Version with
that same null taskId — so the MP4 was uploaded and stored, but the
Version hung off no task and none of the review flows had anywhere to
draw it. From the artist's side the export completed and produced
nothing.

E1 now resolves the shot's comp task inside the version-allocation
transaction and creates one when there isn't any, titled after the
preview file the export will produce: {shotCode}_cmp_TT_{version}, the
same convention the manual batch upload's create-task path already uses.

renderOutputBase() is exported and buildPreviewManifest takes its `base`
from it, so the task title and the MOV/MP4 name come from one function
rather than two copies of the same template. The title therefore already
carries the version, which makes finalizePreview's rename-to-the-
delivered-version a no-op on that first export rather than an immediate
rename of a task created moments earlier.

The lookup and the create sit inside the transaction so the P2002
version-collision retry rolls a losing attempt's task back with
everything else, instead of leaving a duplicate behind.

recalcShotStatus runs only when a task was actually created: a shot with
no tasks derives WAITING and now has one. Approval-driven statuses still
take precedence, so an already-approved shot stays COMPLETE.

Both the queue-time ExportEvent note and the E1 response record what
happened, so a task appearing under a shot on its own is traceable to the
export that made it.

Exports already in flight with a null taskId keep their orphaned
versions; backfilling those is a separate migration.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-28 14:09:01 +02:00
twotalesanimation bac525ddd0 feat(shot-status): shot version beside the name, and a scaled-in-edit flag
Deploy / deploy (push) Successful in 7m28s
Two small board additions.

The shot version now shows next to the shot code. It is Shot.shotVersion —
the value the AE panel burns into overlays and queueExport renders under,
and the one the shot detail page edits — not a count of uploaded review
Versions, so the board agrees with what the artist has in the panel.

Shot.isScaled records that a shot is scaled in the edit: the plate is not
used at its native size, which changes how the shot is comped and
reviewed. That makes it a standing property of the shot rather than
something buried in the notes, so it is flagged the way isKeyShot is — a
cyan pill next to the shot name, and a Scaled toggle column beside Key.
toggleScaledShot() (actions/shots.ts) mirrors toggleKeyShot, same roles.

KeyShotToggle's switch markup would have been duplicated verbatim for the
second flag, so both now sit on a shared FlagToggle taking a colour tone
and a setter. The key-shot switch behaves exactly as before, optimistic
update and rollback included.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-28 09:57:05 +02:00
twotalesanimation 7f066c1372 feat(pipeline): MOV review delivery packages from selected shots
Deploy / deploy (push) Successful in 7m28s
A formal review is shared as a flat, dated folder of the preview MOVs —
{deliveryRoot}/PRODUCER_REVIEWS/20260828_Producer_review, then _02, _03
for further reviews the same day. It reuses the delivery package's
machinery end to end: DeliveryPackage/DeliveryItem, the DELIVERY_BUILD
job, the same claim path and the same hardlink-or-copy builder, with
DeliveryPackage.kind telling the two apart.

Three things separate a review from a delivery:

A review never advances an Export. Reviews happen throughout a shot's
life, long before QC passes it, and the same version is routinely shown
twice — so nothing is marked PACKAGED, and markDelivered() refuses a
review package outright (the button is hidden too).

Selection is by shot, not by export. Shot Status → Bulk Actions → Build
MOV Review Package; the server resolves each shot to its newest export
that actually has a deliveryMovPath, which is not always its newest
export — a shot whose latest version is still rendering belongs in the
review as the version that can be watched. Shots with no MOV at all are
listed in the confirm dialog with the reason rather than silently
shrinking the folder.

The folder is exactly the MOVs. No CSV, no manifest.json written beside
them; the manifest still returns to the server, so the record of what was
shared is kept without cluttering the share. Names follow the same
client-naming rule as a delivery, so a shot reads identically in a review
folder and in the delivery that follows it.

Verification (DeliveryStage.BuildReviewItem) is proportional as it is for
EXRs, adapted to a single file with no validation-time digest: a hard
link is the source and needs nothing, a copy is checked against its
source by length always and by full hash under "always-hash". A missing
MOV fails the item here — in an EXR delivery the MOV is a viewing copy
beside the real deliverable, but in a review it is the deliverable, and a
review folder quietly one shot short is worse than one that says so.

Worker bumped to 1.6.0 for the new manifest field (DeliveryManifest.Kind).

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-28 08:58:21 +02:00
twotalesanimation ed9f9b13c1 feat(client-portal): show shots and task titles in the client's own naming
Deploy / deploy (push) Successful in 6m8s
Shot.clientCode already drove slates, overlay burn-ins and delivered file
names, but the client portal — the one place the client actually reads — was
still showing our internal codes.

Task titles were the larger leak. They follow the house convention
"UNG_106_010_020_cmp_TT_v004", so the internal code sat embedded in the
string the client reads and copies, in three places on the shot list and
again in the player header. Swapping only the heading would have left it on
display directly underneath.

lib/shot-code.ts resolves both: clientShotCode picks the alias when set, and
clientTaskTitle swaps the code out of a title by substring, leaving a
hand-edited title that does not carry the code untouched rather than guessing
at it.

Applied at the API boundary rather than at each render site, so the shot
list, search, playlist labels, alt text, player header and every
copy-to-clipboard button inherit it and nothing downstream has to remember
which code it is holding. The internal code is no longer sent to the browser
on these routes at all.

Slack notifications deliberately keep the internal code: those go to our
artists, who need the code that matches the comp and the SAN path.

The two existing "clientCode || shotCode" expressions in preview.ts and
deliveries.ts now use the same helper so slates, deliveries and the portal
cannot drift apart. Shots with no clientCode are unchanged throughout.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-27 23:16:53 +02:00
twotalesanimation 1fad6a739d fix(worker): drain ffmpeg's pipes so thumbnail generation stops deadlocking
Deploy / deploy (push) Successful in 9m16s
ffmpeg was started with stdout and stderr redirected and neither pipe ever
read. Windows gives an anonymous pipe a ~4 KB buffer, which ffmpeg's banner
and stream summary exceed on their own, so it blocked forever on the write,
never exited, and the two-minute cap fired:

    TaskCanceledException at Process.WaitForExitAsync
    Preview complete for job ... in 221s (mov + mp4)

The exception was swallowed as "non-fatal", so every preview silently
produced no thumbnail while paying 120s for the privilege. Nothing
downstream was wrong — there was simply never a thumbnail to promote.

Both pipes are now drained concurrently before the wait. A timeout kills the
process tree rather than leaking an ffmpeg per job, and attempts report a
three-way outcome so a hung or unstartable ffmpeg is not retried — without
that, the slate fallback would have doubled the wasted time to four minutes.

Failures are no longer silent: an unset or missing ffmpegPath, the seek that
was chosen, and ffmpeg's own exit code, command and stderr are all logged.

finalizePreview likewise records every promotion outcome on the export
timeline, not just success. Silence there was indistinguishable from a broken
worker, a project whose flag never saved, and the feature working as
configured — which is what made this take so long to find.

Adds scripts/diagnose-thumbnails.mjs, which walks the chain (ffmpeg →
Export.thumbnailKey → project flag → Shot.generatedThumbnailUrl → what the UI
resolves) and names the first broken link.

Worker 1.5.1 -> 1.5.2; republish required for the fix to take effect.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-27 22:48:29 +02:00
twotalesanimation 9cd7b0df6e chore: retrigger deploy
Deploy / deploy (push) Successful in 5s
Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-08-27 17:23:42 +02:00
twotalesanimation caaa333f02 feat(pipeline): render-derived shot thumbnails, and bulk shot delete
Deploy / deploy (push) Failing after 19m11s
Two independent features landing together:

Generated shot thumbnails — a shot can now carry a thumbnail promoted
from a render export (Shot.generatedThumbnailUrl/generatedThumbnailFrom)
alongside the existing brief-supplied thumbnailUrl, which always takes
display precedence (lib/shot-thumbnail.ts) so a promoted frame can only
ever fill a gap, never overwrite the brief. Shows with
pipelineConfig.autoShotThumbnail promote automatically on every
finished export (lib/render-pipeline/preview.ts); promoteExportThumbnail/
clearGeneratedThumbnail (actions/shots.ts) are the manual equivalent for
everyone else. Worker-side seek logic for picking the promoted frame is
covered by RenderWorker/VFXReviewWorker.Tests/ThumbnailSeekTests.cs.

Bulk shot delete — the shot-status page's selection bar gets a "Bulk
Actions" dropdown (alongside the existing Change Due Date) with Delete
Shots. bulkDeleteShots() (actions/shots.ts) deletes one at a time rather
than in a single statement: exports_shotId_fkey is ON DELETE RESTRICT
by design, so a shot with renders or deliveries on record is protected
and gets skipped and reported by name rather than aborting the whole
selection or being silently destroyed along with its history.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-08-27 17:06:55 +02:00
twotalesanimation b151e8cc52 feat(pipeline): per-shot client naming alias for slates, overlays, and delivery
Deploy / deploy (push) Successful in 7m25s
Clients sometimes ship footage under a naming convention that doesn't
match our own shot codes. Adds an optional Shot.clientCode, editable on
the Slate tab: when set, it replaces shotCode only in what the client
actually sees — slate identity, overlay burn-in, and delivered EXR/MOV
file and folder names in Netflix packages — with our own version string
flatly appended (no "_cmp_TT_" studio jargon mixed in). Internal render
paths, EXR filenames on the SAN, comp names, and DB lookups are
untouched. Shots without a client code render identically to before.

Delivery packages denormalize clientCode at build time, same as the
existing shotCode/versionString snapshot, so a later shot edit can't
retroactively change already-built delivery history. The worker now
renames delivered EXR frames and the delivery MOV using the existing
frame-number parser (SequencePattern) so only the base name changes —
frame numbers and padding survive exactly. This is the one piece of the
change that could plausibly ship the wrong bytes, so it's covered by
new unit tests (renaming, padding, MOV rename, checksum-survives-rename,
and a graceful fallback for an unparseable frame number) rather than
resting on manual verification alone.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-08-26 00:38:12 +02:00
twotalesanimation 26a4719c2a fix(connector): strip reference LUT/overlay before Queue Export renders EXRs
Build Shot adds the show LUT and overlay burn-in into the artist's main
comp, enabled by default, for reference while compositing. The legacy
manual "Queue EXR" button has always disabled both before rendering;
Queue Export (the pipeline's one-click path) never got that same step,
so EXRs queued through it could ship with the LUT graded in and the
burn-in baked on. Queue Export now disables them the same way, right
before the project save the render worker reads from.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-08-25 22:47:42 +02:00
203 changed files with 19923 additions and 1342 deletions
+11
View File
@@ -0,0 +1,11 @@
{
"version": "0.0.1",
"configurations": [
{
"name": "web",
"runtimeExecutable": "npm",
"runtimeArgs": ["run", "dev"],
"port": 3000
}
]
}
+138 -9
View File
@@ -2,6 +2,11 @@
How a finished shot becomes a dated folder ready to upload to the client. How a finished shot becomes a dated folder ready to upload to the client.
There are two kinds of package. An **EXR delivery** is the shippable one and is
what most of this guide describes. A **MOV review** is a flat folder of preview
MOVs shared for a formal review — see
[MOV review packages](#mov-review-packages) at the end.
This is the operational guide. The design rationale and normative rules live in This is the operational guide. The design rationale and normative rules live in
[RenderPipeline2.md](RenderPipeline2.md) §11. [RenderPipeline2.md](RenderPipeline2.md) §11.
@@ -15,9 +20,14 @@ This is the operational guide. The design rationale and normative rules live in
18 shots"*, click **Build delivery**. 18 shots"*, click **Build delivery**.
3. A render worker builds the folder on the delivery volume, verifies every 3. A render worker builds the folder on the delivery volume, verifies every
file, and writes a manifest and CSV report. file, and writes a manifest and CSV report.
4. A human uploads that folder to the client, then clicks **Mark delivered**. 4. A human uploads that folder to the client and clicks **Record upload**,
pasting the link to where it now lives.
5. They send the client that link and click **Share link**, recording who it
went to. Only then is the package `DELIVERED`.
Nothing is ever sent to the client automatically. Step 4 is deliberately manual. Nothing is ever sent to the client automatically. Steps 4 and 5 are deliberately
manual — but until both are recorded the package sits in **Awaiting delivery**
at the top of the dashboard.
--- ---
@@ -64,8 +74,8 @@ Watch the package status on the same page:
|---|---| |---|---|
| `QUEUED` | Waiting for a worker to pick it up | | `QUEUED` | Waiting for a worker to pick it up |
| `BUILDING` | A worker is creating folders and linking files | | `BUILDING` | A worker is creating folders and linking files |
| `READY` | Built and verified — upload it | | `READY` | Built and verified. Shown as *Built — not uploaded*, then *Uploaded — link not shared* |
| `DELIVERED` | You confirmed the client has it | | `DELIVERED` | The upload location and who the link was sent to are both on record |
| `FAILED` | Something did not verify — see the error and the per-shot list | | `FAILED` | Something did not verify — see the error and the per-shot list |
| `CANCELLED` | Abandoned before delivery | | `CANCELLED` | Abandoned before delivery |
@@ -161,11 +171,59 @@ so it is logged and the package continues without it.
## Marking delivered ## Marking delivered
Once you have uploaded the folder, **Mark delivered** moves every packaged A built package is not a delivered one, so delivery is two recorded steps. Both
export to `DELIVERED`. Requires admin, producer or supervisor. require admin, producer or supervisor.
This is the end of the pipeline, and it is a human statement of fact — the app 1. **Record upload** — paste the link to the folder on the client's portal and
has no way to know the client received anything. confirm it matches the shot, frame and MOV counts shown. The link can be
corrected until it is shared.
2. **Share link** — copy the generated message (link, shots, versions), send it,
and record who it went to. This moves every packaged export to `DELIVERED`.
The second step is refused until the first is on record. Meanwhile the package
is listed under **Awaiting delivery** on the dashboard, amber after a day and
red after two.
This is still a human statement of fact — the client's portal has no API, so
the app cannot see the upload itself. What it guarantees is that nothing reads
as delivered without a link, a recipient, a name and a time behind it. Packages
delivered before this existed show as delivered with no evidence recorded.
---
## Delivery requests
When a client asks for something ("EXRs for 116"), log it so it cannot be
forgotten. Requires admin, producer or supervisor.
- **Dashboard → Awaiting delivery → Log request**, or the same button on
**Pipeline → Deliveries**: pick the project, then a whole episode or a pasted
list of shot codes (ours or the client's; a code that matches nothing is
refused rather than skipped).
- **Shot Status → Bulk Actions → Log Delivery Request** for a ticked selection.
The shot list is a snapshot taken when the request is logged. The request then
sits in **Awaiting delivery** showing *"3 of 9 delivered"*, and on the
deliveries page every shot shows where it stands: not through QC, in QC, ready
to package, building, built, uploaded, delivered. **Build N ready** packages
the shots that have passed QC.
A request has no "done" button. A shot's line closes only when:
- a package containing it is shared (step 2 of marking delivered) after the
request was logged, or
- it is marked **Delivered Outside Pipeline** with the upload link and who the
link was sent to, dated on or after the day the request was logged. For a
shot on an open request those two fields are required.
The request closes when every line has. A delivery made *before* the request
was logged does not count — a client asking again is asking for it again. The
only other way out is **Cancel request**, which needs a reason and stays in the
history.
The *Wanted* field (EXRs, MOVs, both) records what was asked for; it does not
change what closes a line. A MOV-only ask is closed through Delivered Outside
Pipeline, since a MOV review package has no delivered state.
--- ---
@@ -228,11 +286,82 @@ a different spec is a config change rather than a code change.
| E16 | `POST` | `/api/deliveries` | Create a package and queue the build | | E16 | `POST` | `/api/deliveries` | Create a package and queue the build |
| E17 | `GET` | `/api/deliveries` | List packages / history | | E17 | `GET` | `/api/deliveries` | List packages / history |
| E18 | `GET` | `/api/deliveries/ready` | Ready exports grouped by episode | | E18 | `GET` | `/api/deliveries/ready` | Ready exports grouped by episode |
| E19 | `POST` | `/api/deliveries/{id}/delivered` | Mark delivered | | — | `POST` | `/api/deliveries/{id}/uploaded` | Record the upload: `{ uploadUrl, contentsConfirmed: true }` |
| E19 | `POST` | `/api/deliveries/{id}/delivered` | Record the share and mark delivered: `{ sharedWith, note? }` |
| — | `POST` | `/api/deliveries/{id}/cancel` | Cancel a package | | — | `POST` | `/api/deliveries/{id}/cancel` | Cancel a package |
| — | `GET` | `/api/delivery-requests` | List requests with per-shot stages (`?projectId=`, `?open=1`) |
| — | `POST` | `/api/delivery-requests` | Log a request: `{ projectId, episode \| shotIds \| shotCodes, deliverable, requestedBy, dueDate?, note? }` |
| — | `POST` | `/api/delivery-requests/{id}/cancel` | Cancel a request: `{ reason }` |
| — | `POST` | `/api/ext/render/jobs/{jobId}/delivery` | Worker reports a build (API key) | | — | `POST` | `/api/ext/render/jobs/{jobId}/delivery` | Worker reports a build (API key) |
`POST /api/deliveries` takes `{ projectId, episode?, exportIds?, options? }`. `POST /api/deliveries` takes `{ projectId, episode?, exportIds?, options? }`.
Omit `exportIds` to take every ready export in the episode; `options` accepts Omit `exportIds` to take every ready export in the episode; `options` accepts
`date`, `name`, `includeMovs` and `copyMode` to override the config for one `date`, `name`, `includeMovs` and `copyMode` to override the config for one
build. build.
---
## MOV review packages
For a formal review you share the preview MOVs, not the EXRs. That is its own
kind of package, built the same way and listed on the same page.
### Building one
**Shot Status**, tick the shots, then **Bulk Actions → Build MOV Review
Package**. A dialog shows exactly what would be built before anything happens:
the folder name, the version each shot contributes, and any shots being left
out. Requires **admin, producer or supervisor**.
The version each shot contributes is its **newest export that actually has a
preview MOV** — not necessarily its newest export. A shot whose latest version
is still rendering goes into the review as the version that can be watched.
A shot with no MOV at all is listed as left out, with the reason, rather than
quietly reducing the folder.
### What lands on disk
```
{deliveryRoot}/PRODUCER_REVIEWS/20260828_Producer_review/
├── EP6_VFX_012_v004.mov
├── EP6_VFX_013_v002.mov
└── UNG_106_010_040_cmp_TT_v001.mov
```
Flat — the MOVs sit beside each other so they can be scrubbed through in order.
Names follow the same client-naming rule as a delivery: the production's own
code where it has one, ours where it does not, so a shot reads identically in a
review folder and in the delivery that follows it.
The folder is **exactly the MOVs**: no CSV, no `manifest.json` beside them. The
manifest still goes back to the app, so the record of what was shared is kept
without cluttering the share.
Second review the same day is `20260828_Producer_review_02`, then `_03`. A
number is never reused, even if the package that took it was cancelled.
### What it does not do
**A review never moves a shot along.** Reviews happen throughout a shot's life,
long before QC passes it, and the same version is routinely shown twice — so
building one changes nothing about the exports in it, and there is no
**Mark delivered** on a review package. Shots stay exactly where they are in
the pipeline.
A **missing MOV fails the package** here, unlike in an EXR delivery where a
missing MOV is logged and the build continues. In a review the MOV is the
deliverable, and a review folder quietly one shot short is worse than one that
says so.
### Configuration
Two more keys in the same `deliveryConfig` (§11.6):
```json
{
"reviewNameTemplate": "{yyyymmdd}_Producer_review",
"layout": {
"reviewDir": "{deliveryRoot}/PRODUCER_REVIEWS/{packageName}"
}
}
```
+1
View File
@@ -542,4 +542,5 @@ For reference, the endpoints called by `VFXReviewConnector.jsx`:
| Retry Export | `POST /api/ext/exports/{id}/retry` (E14) | | Retry Export | `POST /api/ext/exports/{id}/retry` (E14) |
| Regenerate Previews | `POST /api/ext/exports/{id}/regenerate-preview` | | Regenerate Previews | `POST /api/ext/exports/{id}/regenerate-preview` |
| Load QC Queue | `GET /api/ext/qc/queue?projectCode={PROJECT_CODE}` (E5) | | Load QC Queue | `GET /api/ext/qc/queue?projectCode={PROJECT_CODE}` (E5) |
| Build QC Review Session | `GET /api/ext/qc/queue?projectCode={PROJECT_CODE}` (E5): uses `scene`, `episode`, `seqTimecodeStart`, `handleHead`, `handleTail` |
| QC Pass / QC Fail | `POST /api/ext/exports/{id}/qc` (E4) | | QC Pass / QC Fail | `POST /api/ext/exports/{id}/qc` (E4) |
+77 -3
View File
@@ -207,7 +207,7 @@ stateDiagram-v2
| T9 | VALIDATION_FAILED | QUEUED | Retry (full re-render) | User | new attempt; old validation rows kept for history | | T9 | VALIDATION_FAILED | QUEUED | Retry (full re-render) | User | new attempt; old validation rows kept for history |
| T10 | GENERATING_PREVIEW | PREVIEW_FAILED | ffmpeg/upload failure | Worker | error stored | | T10 | GENERATING_PREVIEW | PREVIEW_FAILED | ffmpeg/upload failure | Worker | error stored |
| T11 | PREVIEW_FAILED | GENERATING_PREVIEW | Retry preview | User | validation is NOT re-run | | T11 | PREVIEW_FAILED | GENERATING_PREVIEW | Retry preview | User | validation is NOT re-run |
| T12 | GENERATING_PREVIEW | READY_FOR_QC | `finalize` report | Worker | `Version` row created (isLatest, **never client-shared**), thumbnail set, metadata JSON key stored; **no task/shot status change** — QC typically runs on already client-approved shots and must not disturb review state (Section 10) | | T12 | GENERATING_PREVIEW | READY_FOR_QC | `finalize` report | Worker | `Version` row created (isLatest, **never client-shared**), thumbnail set, metadata JSON key stored; `Shot.generatedThumbnailUrl` set when the project opts in (§9.1a) — never `Shot.thumbnailUrl`; **no task/shot status change** — QC typically runs on already client-approved shots and must not disturb review state (Section 10) |
| T13 | READY_FOR_QC | QC_FAILED | `POST .../qc {FAIL}` | Artist (AE) or user (web) | `QCReview` row; task → CHANGES (drives existing Shot REVISIONS derivation) | | T13 | READY_FOR_QC | QC_FAILED | `POST .../qc {FAIL}` | Artist (AE) or user (web) | `QCReview` row; task → CHANGES (drives existing Shot REVISIONS derivation) |
| T14 | READY_FOR_QC | READY_FOR_DELIVERY | `POST .../qc {PASS}` | Artist / user | `QCReview` row | | T14 | READY_FOR_QC | READY_FOR_DELIVERY | `POST .../qc {PASS}` | Artist / user | `QCReview` row |
| T15 | READY_FOR_DELIVERY | PACKAGED | Delivery build completes | Worker | `DeliveryItem` links Export to package | | T15 | READY_FOR_DELIVERY | PACKAGED | Delivery build completes | Worker | `DeliveryItem` links Export to package |
@@ -268,6 +268,9 @@ model Export {
shot Shot @relation(fields: [shotId], references: [id]) shot Shot @relation(fields: [shotId], references: [id])
projectId String projectId String
taskId String? // comp task the preview Version attaches to taskId String? // comp task the preview Version attaches to
// (E1 creates one named after the preview file
// when the shot has none, so the preview lands
// somewhere the app shows it)
versionId String? // preview Version created at READY_FOR_QC versionId String? // preview Version created at READY_FOR_QC
versionNumber Int // 4 versionNumber Int // 4
versionString String // "v004" versionString String // "v004"
@@ -448,6 +451,7 @@ model DeliveryPackage {
projectId String projectId String
episode String // "101" episode String // "101"
name String // "260805_Delivery" (per 18.1-Q6 convention) name String // "260805_Delivery" (per 18.1-Q6 convention)
kind DeliveryKind @default(EXR_DELIVERY) // EXR_DELIVERY | MOV_REVIEW (§11.6)
packageNumber Int // sequential per project → "Package #15" packageNumber Int // sequential per project → "Package #15"
status DeliveryStatus @default(DRAFT) status DeliveryStatus @default(DRAFT)
rootPath String? // final path on delivery volume rootPath String? // final path on delivery volume
@@ -464,6 +468,7 @@ model DeliveryPackage {
@@unique([projectId, packageNumber]) @@unique([projectId, packageNumber])
@@index([projectId, episode]) @@index([projectId, episode])
@@index([projectId, kind])
} }
model DeliveryItem { model DeliveryItem {
@@ -488,6 +493,8 @@ model DeliveryItem {
**Version locking:** the package references `Export` rows, and items denormalise `shotCode`/`versionString` at creation. Later re-renders of a shot never mutate a package — delivery history is immutable by construction. **Version locking:** the package references `Export` rows, and items denormalise `shotCode`/`versionString` at creation. Later re-renders of a shot never mutate a package — delivery history is immutable by construction.
**`kind`** distinguishes a shippable EXR delivery from a MOV review folder (§11.6). Both use these two models and the same `DELIVERY_BUILD` job; only a review leaves `exrPath` null, and only a delivery advances its exports to PACKAGED/DELIVERED.
### 5.8 Changes to existing models (additive only) ### 5.8 Changes to existing models (additive only)
| Model | Addition | Purpose | | Model | Addition | Purpose |
@@ -1066,6 +1073,8 @@ Timecode is the check this engine exists for. It is validated **against the sour
| 2 | Plate re-derived on the worker from the footage root + shot code (manifestVersion 1, or a timing plate that no longer resolves). If elements disagree, the one matching the render's frame count wins; still ambiguous → WARN, never PASS | PASS / FAIL, `reference: "derived"` | | 2 | Plate re-derived on the worker from the footage root + shot code (manifestVersion 1, or a timing plate that no longer resolves). If elements disagree, the one matching the render's frame count wins; still ambiguous → WARN, never PASS | PASS / FAIL, `reference: "derived"` |
| 3 | API `Shot.timecodeStart` **minus `handleFrames`** | **WARN only, never PASS** — `reference: "api"`, message states the plate could not be read | | 3 | API `Shot.timecodeStart` **minus `handleFrames`** | **WARN only, never PASS** — `reference: "api"`, message states the plate could not be read |
**Several delivered elements.** When the rank-1 timing plate does not match, the worker tries the manifest's other `plates[]` before failing — the panel's longest-duration pick is not always the element the comp was anchored to. A match against one of them is a PASS naming that element; no match still FAILs against the timing plate, listing the others tried. Only delivered footage qualifies: plates under a configured plate search root, or (with none configured) alongside the timing plate in its footage folder. `plates[]` also holds pre-renders, which agree with the render by construction and must never rescue it.
Rank 3 is a diagnostic, not a verification: it depends on the show's handle count being correct for that specific plate, which is exactly the assumption the defects above violate. Rank 3 is a diagnostic, not a verification: it depends on the show's handle count being correct for that specific plate, which is exactly the assumption the defects above violate.
**Comparison, given the plate reference:** **Comparison, given the plate reference:**
@@ -1100,18 +1109,36 @@ Runs on the worker after validation passes (Export = GENERATING_PREVIEW).
### 9.1 Stages ### 9.1 Stages
1. **Build + render preview comp (AE, headless).** The worker launches `AfterFX.com -noui -r vfxr_build_preview.jsx`, passing a job-context JSON file (manifest + slate/overlay fields fetched from E3). The script is the connector's existing preview-comp code, packaged with the worker: it imports the *validated* EXR sequence, builds the preview comp from the studio template (head slate populated from API data, overlays/burn-ins throughout), applies the colour chain (linear → log → show LUT from `colorPipeline` config), queues it with the project's MOV output-module template, and renders the **delivery-grade preview MOV** to the SAN beside the EXRs (`Export.deliveryMovPath`). This is the "MOV LT Preview" that ships inside delivery packages (Section 11). 1. **Build + render preview comp (AE, headless).** The worker launches `AfterFX.com -noui -r vfxr_build_preview.jsx`, passing a job-context JSON file (manifest + slate/overlay fields fetched from E3). The script is the connector's existing preview-comp code, packaged with the worker: it imports the *validated* EXR sequence, builds the preview comp from the studio template (head slate populated from API data, overlays/burn-ins throughout), applies the colour chain (linear → log → show LUT from `colorPipeline` config), queues it with the project's MOV output-module template, and renders the **delivery-grade preview MOV** to the SAN beside the EXRs (`Export.deliveryMovPath`). This is the "MOV LT Preview" that ships inside delivery packages (Section 11).
2. **Web transcode (ffmpeg).** The delivery MOV is transcoded to a web-playable H.264 (1920-wide, CRF 18) and a thumbnail JPEG (frame at 25% duration, 960-wide), uploaded via E20 presign. 2. **Web transcode (ffmpeg).** The delivery MOV is transcoded to a web-playable H.264 (1920-wide, CRF 18) and a thumbnail JPEG (960-wide), uploaded via E20 presign. The thumbnail is taken at **25% of *picture* duration**, seeking past the head slate: the build script reports the SHOT layer's in-point as `pictureStartSeconds`, and the worker seeks to `pictureStart + 25%`. Builds that report no picture start fall back to scanning the whole file. (Until 2026-08-27 this used ffmpeg's `thumbnail` filter, which only considers the first 100 frames — on a slated preview, the slate card. Every thumbnail produced before then is a picture of the slate.)
3. **Metadata JSON.** Worker-composed (manifest + validation summary + render stats + checksums + tool/template versions), uploaded via E20. 3. **Metadata JSON.** Worker-composed (manifest + validation summary + render stats + checksums + tool/template versions), uploaded via E20.
| Artifact | Produced by | Destination | | Artifact | Produced by | Destination |
|---|---|---| |---|---|---|
| Delivery MOV (slate + burn-ins, graded via show LUT, delivery codec from AE output template) | AE headless render | SAN → `Export.deliveryMovPath`; copied/linked into delivery packages | | Delivery MOV (slate + burn-ins, graded via show LUT, delivery codec from AE output template) | AE headless render | SAN → `Export.deliveryMovPath`; copied/linked into delivery packages |
| Web preview MOV (H.264) | ffmpeg transcode of the delivery MOV | object storage `videos/` → `Version.fileUrl` | | Web preview MOV (H.264) | ffmpeg transcode of the delivery MOV | object storage `videos/` → `Version.fileUrl` |
| Thumbnail | ffmpeg | `image/` → `Version.thumbnailUrl` + `Export.thumbnailKey` | | Thumbnail | ffmpeg | `image/` → `Version.thumbnailUrl` + `Export.thumbnailKey`; also `Shot.generatedThumbnailUrl` when the project opts in (§9.3) |
| Metadata JSON | worker | `renders/` → `Export.metadataKey` | | Metadata JSON | worker | `renders/` → `Export.metadataKey` |
Because the web preview is a transcode of the AE-generated MOV, review media and delivery media are guaranteed to show identical slates, burn-ins, and colour — one source of truth. Because the web preview is a transcode of the AE-generated MOV, review media and delivery media are guaranteed to show identical slates, burn-ins, and colour — one source of truth.
### 9.1a Render frames as shot thumbnails
Shots carry two stills, in two columns, and the distinction is the whole design:
| Column | Written by | Meaning |
|---|---|---|
| `Shot.thumbnailUrl` | humans only — single upload, batch upload, ext API | The reference frame that came with the brief. Editorial data. |
| `Shot.generatedThumbnailUrl` | the pipeline, and the manual promote action | A frame lifted from a finished export. |
Display resolution is `thumbnailUrl ?? generatedThumbnailUrl` (`lib/shot-thumbnail.ts`), applied at every shot surface: shot grid, kanban, schedule, shot status, storyboard (screen and PDF), shoot log, slate tab, client portal, and the ext APIs the Nuke/AE panel reads. **The reference always wins**, so the pipeline can only fill a gap and can never overwrite the brief — clearing the generated one always falls back.
Promotion happens two ways:
* **Automatically**, for projects with `pipelineConfig.autoShotThumbnail` set (Project Settings → *Use render frames as shot thumbnails*). Off by default and deliberately per-show: productions that ship a still with every shot already have a reference frame and the renders should not compete with it. It exists for shows that arrive with no stills at all, where the alternative is an empty grid. `finalizePreview` writes the column and notes it on the export timeline.
* **By hand**, via `promoteExportThumbnail` / `clearGeneratedThumbnail` (Shot Settings → Thumbnail → *From renders*), which work regardless of the project flag — one shot on an otherwise hands-off show. With no explicit export, the newest export of that shot that has a thumbnail is used.
Note this is the one place a render-derived artifact reaches the client portal. It is a still, not a `Version`, so §10.0 is intact — no technical render re-enters the review flow and no approval state moves — but a client viewing a shot with no supplied still now sees a frame from the render rather than a placeholder.
### 9.2 Colour configuration ### 9.2 Colour configuration
`Project.deliveryConfig.colorPipeline` (per 18.1-Q4/Q12) — **required and unique per project**; enabling the pipeline on a project without it is a validation error, and values must never be carried over from another show: `Project.deliveryConfig.colorPipeline` (per 18.1-Q4/Q12) — **required and unique per project**; enabling the pipeline on a project without it is a validation error, and values must never be carried over from another show:
@@ -1152,6 +1179,27 @@ Not every export is framed like its review. A deliverable rendered unscaled or w
With no earlier export to inherit from, the export still reaches READY_FOR_QC and the timeline records that it has no review media. With no earlier export to inherit from, the export still reaches READY_FOR_QC and the timeline records that it has no review media.
### 9.5 Handles in review (metadata only)
Renders run past the cut at each end (8 + 8 by house convention). Handles ship with the EXRs and stay in the preview, but reviewers must be able to tell them from the cut, or a glitch in a handle gets flagged as a problem in the shot. **Nothing is trimmed or burned in** — this is deliberately not the reverted picture-lock trim (which desynced the overlay timecode); the render and every delivered file are unchanged.
- **Panel:** "Includes handles [8] frames each end" (default on, prefilled from Handle Frames) sends `manifest.review = { handleHead, handleTail }`; unticked sends 0/0. Manifests without `review` (older panels) fall back to `source.handleFrames` (`manifestHandles`, exports.ts).
- **Export → Version:** `createExport` stores `Export.handleHead/handleTail`; `finalizePreview` copies them onto the Version, plus `pictureStartFrame` = the head slate length from the build's `pictureStartSeconds` (worker ≥ 1.6.4). Left null, the player infers the slate as MP4 frames − `frameCount` (the EXR count), within 0–5 frames.
- **Player** (`lib/handles.ts` → `computeEditRange`): the timeline hatches the handles amber and labels them HANDLE (the slate, SLATE); while the playhead is in a handle the picture gets an amber frame and a "HEAD/TAIL HANDLE · NOT IN EDIT" tag; notes on handle frames carry a HANDLE badge. "Edit range only" (scissors) keeps play, reverse and go-to-start/end inside the cut — on by default in the client portal, off for staff.
- **Staff override:** the review page's Handles button edits a version's head/tail/slate — for manual uploads, or to correct a render.
- **Backfill** (`20260922000000_version_handles`): every existing export takes its manifest's `source.handleFrames` (else 8), and the Versions they produced take the same.
### 9.6 High quality playback and the ProRes download
The Standard review MP4 is AE's H.264 (UHD, ~35 Mbps). ProRes itself can't be the player's source — only Safari on a Mac decodes it in a web page, and UHD ProRes LT is ~280 Mbps — so the worker (≥ 1.7.0, when `preview.highQuality` is on) adds two things after the AE render, both **best-effort** (a failure costs the extras, never the preview):
- **High quality MP4:** ffmpeg re-encodes the delivery MOV as full-res H.264 High, CRF 14 capped at 100 Mbps, yuv420p, faststart → `Version.hqFileUrl`. The player shows an **HQ** switch when present; switching keeps frame, play state, speed and zoom, is remembered per browser (`review:quality`), and falls back to Standard if the file won't load. Same comp as the Standard MP4, so slate and handles line up frame for frame.
- **ProRes download:** the MOV itself is uploaded (presign kind `highres`) → `Version.highResKey/highResFilename/highResSize`. It is the version's **High Res** download in the client portal (named with the client code, `clientHighResFilename`) and a **ProRes** button on the staff review page. The shot's manually uploaded High Res remains the fallback for versions without one. Since worker 1.7.1 the MOV uploads **in the background after finalize** (`HighResUploader`, queue in `%ProgramData%\VFXReviewWorker\highres-queue`, resumes after a restart, 5 attempts) and attaches via `POST /api/ext/render/jobs/{id}/attach-highres` (E13b); a MOV from a preview that a newer preview has superseded is discarded. While a preview job uploads, the worker replaces the job's log tail with live upload status. Since 1.7.2, artifacts of 16 MB or more upload as S3 multipart: `artifact-presign` with `multipart: true, size` returns `uploadId`, `partSize` (8 MB minimum) and one presigned URL per part; the worker PUTs parts on `uploadConcurrency` connections (default 16), retries each part up to 4 times, then calls `artifact-complete` (E20b) to stitch them, or with `abort: true` to discard them. A single connection from the studio to nbg1 is capped near 0.1 MB/s.
A lease keep-alive runs during the encode and uploads (they can outlast the 300 s lease). The export timeline records what was attached.
**Housekeeping** (`lib/render-pipeline/high-res.ts`): a version keeps its HQ MP4 and ProRes while it is the task's latest, shared with the client, approved, or younger than `preview.highResRetentionDays` (14). Otherwise both are deleted from storage and the row gets `highResPrunedAt`; the Standard MP4 is never touched. It runs for the task after every finalize and studio-wide hourly from the reaper; deleting a version deletes its files. A reslate replaces (and deletes) the version's previous HQ/ProRes.
--- ---
## 10. QC Workflow ## 10. QC Workflow
@@ -1230,6 +1278,27 @@ Tokens: `{showId} {episode} {yymmdd} {yyyymmdd} {packageName} {packageDir} {shot
The Delivery Packages page (Section 13) lists every package permanently: `#15 · 101/260805_Delivery · Episode 101 · 18 shots · built 2026-08-05 · delivered 2026-08-05 by Chris`, expandable to items → Export → full render/validation/QC history. Packages are never deleted; a mistaken package is CANCELLED (DRAFT/QUEUED/FAILED only) or superseded by building a new one. The Delivery Packages page (Section 13) lists every package permanently: `#15 · 101/260805_Delivery · Episode 101 · 18 shots · built 2026-08-05 · delivered 2026-08-05 by Chris`, expandable to items → Export → full render/validation/QC history. Packages are never deleted; a mistaken package is CANCELLED (DRAFT/QUEUED/FAILED only) or superseded by building a new one.
### 11.6 MOV review packages (`DeliveryPackage.kind = MOV_REVIEW`)
A formal review is shared as a flat, dated folder of the preview MOVs — the same package/job/verification machinery as §11.1–11.5, a different shape on disk:
```
{deliveryRoot}/PRODUCER_REVIEWS/20260828_Producer_review/
├── EP6_VFX_012_v004.mov ← client naming where the production supplies it
├── EP6_VFX_013_v002.mov
└── UNG_106_010_040_cmp_TT_v001.mov ← ours where it does not
```
The second review that day is `_02`, the third `_03`; the first carries no suffix. Numbering counts every package built under that base — cancelled and failed ones included — so a number is never reused for a different folder. Config: `reviewNameTemplate` (default `{yyyymmdd}_Producer_review`) and `layout.reviewDir` (default `{deliveryRoot}/PRODUCER_REVIEWS/{packageName}`).
Three rules separate a review from a delivery:
- **It never advances an Export.** Reviews happen throughout a shot's life, long before QC passes it, and the same version is routinely shown twice. Nothing is marked PACKAGED or DELIVERED when the folder is built, and `Mark delivered` is refused on a review package.
- **Selection is by shot, not by export.** The user picks shots on Shot Status → *Bulk Actions → Build MOV Review Package*; the server resolves each to its **newest export that actually has a `deliveryMovPath`** — not necessarily its newest export, since a shot whose latest version is still rendering should go into the review as the version that can be watched. Shots with no MOV at all are listed in the confirm dialog and left out rather than silently dropped.
- **The folder is exactly the MOVs.** No CSV, no `manifest.json` written beside them. The manifest still returns to the server, so the record of what was shared is kept without cluttering the share.
Verification is proportional as in §11.3, adapted to a single file with no validation-time digest: a hard link is the source and needs nothing; a copy is checked against its source by length always, and by full hash under `"verifyMode": "always-hash"`. A missing MOV **fails the item** here — in an EXR delivery the MOV is a viewing copy beside the real deliverable, but in a review it *is* the deliverable, and a review folder quietly one shot short is worse than one that says so.
--- ---
## 12. AE Panel Changes ## 12. AE Panel Changes
@@ -1246,6 +1315,11 @@ The panel keeps all existing capabilities (episode/shot discovery, overlays, pic
| Latest Export + QC status | new E2 `exports/latest` — e.g. `v004 — READY_FOR_QC`, `v004 — RENDERING 42% (ETA 1:36 on RENDER-01)`, `v003 — QC FAILED: "grain mismatch"` | | Latest Export + QC status | new E2 `exports/latest` — e.g. `v004 — READY_FOR_QC`, `v004 — RENDERING 42% (ETA 1:36 on RENDER-01)`, `v003 — QC FAILED: "grain mismatch"` |
While an export is active the panel polls E2 every 15 s to live-update the header. While an export is active the panel polls E2 every 15 s to live-update the header.
The poll stops when the export leaves an active status, and also when the panel is
closed or reloaded — `app.scheduleTask` outlives the panel instance that armed it,
so the task id is kept in ExtendScript global scope where the next instance can
still cancel it. The export is unaffected either way: it runs on the farm, and the
header picks its status back up on the next Refresh.
### 12.2 Buttons and their API calls ### 12.2 Buttons and their API calls
+3
View File
@@ -208,6 +208,9 @@ read back from the assembly, so a machine can never report a version it is not r
`pathMappings` translate the manifest's canonical UNC paths to this machine's drive `pathMappings` translate the manifest's canonical UNC paths to this machine's drive
mappings. `plateSearchRoots` is optional: it is only consulted when a manifest carries no mappings. `plateSearchRoots` is optional: it is only consulted when a manifest carries no
timing plate (older panel versions), to find the shot's plates for the timecode check. timing plate (older panel versions), to find the shot's plates for the timecode check.
`uploadConcurrency` (default 16) is how many parallel connections a file of 16 MB or more
uploads over. Each connection to object storage is capped near 0.1 MB/s from the studio, so
throughput scales with it (measured 2026-10-01: 1 → 0.13 MB/s, 8 → 0.64, 24 → 1.69 MB/s).
Everything tunable (poll interval, lease, stall timeout, max attempts, validation) lives in Everything tunable (poll interval, lease, stall timeout, max attempts, validation) lives in
the server's SystemConfig and arrives at registration — no per-machine tuning files. the server's SystemConfig and arrives at registration — no per-machine tuning files.
@@ -73,6 +73,46 @@ public class BlenderProgressParserTests
Assert.Equal(1002, frames[^1]); Assert.Equal(1002, frames[^1]);
} }
/// <summary>
/// Blender 5.x prefixes every line with elapsed time and a log category.
/// Anchored on "Saved:", the parser counted no frames from a render that
/// wrote every one, and the job failed as "saved no frames".
/// These lines are verbatim Blender 5.2 output.
/// </summary>
[Fact]
public void ParsesBlender5PrefixedOutput()
{
Assert.Equal(@"X:\renders\frame_0001.png",
BlenderProgressParser.ParseSaved(@"00:02.954 render | Saved: 'X:\renders\frame_0001.png'"));
Assert.Equal(1, BlenderProgressParser.ParseFrame("00:02.469 render | Fra: 1 | Mem: 0M | Synchronizing object | Cube"));
Assert.Null(BlenderProgressParser.ParseSaved("00:02.954 render | Time: 00:00.87 (Saving: 00:00.14)"));
Assert.Null(BlenderProgressParser.ParseFrame("00:02.079 render | Rendering frame 1"));
}
[Fact]
public void RecognisesBlender5Errors()
{
const string unwritable = @"00:03.063 reports | ERROR Render error (No such file or directory) cannot save: 'Q:\out\f_0001.png'";
Assert.True(BlenderProgressParser.IsErrorLine(unwritable));
Assert.True(BlenderProgressParser.IsNonRetryableError(unwritable));
const string missing = @"00:13.250 reports | ERROR Cannot read file ""X:\gone.blend"": No such file or directory";
Assert.True(BlenderProgressParser.IsErrorLine(missing));
Assert.True(BlenderProgressParser.IsNonRetryableError(missing));
}
/// <summary>
/// Add-ons print warnings on every launch; one must never become the
/// reported reason a render failed.
/// </summary>
[Theory]
[InlineData("Warning: add-on missing 'bl_info', this can cause poor performance!: 'G:\\addons\\x\\__init__.py'")]
[InlineData("00:01.000 addon | WARNING something harmless")]
public void WarningsAreNotErrors(string line)
{
Assert.False(BlenderProgressParser.IsErrorLine(line));
}
/// <summary>Mirrors BlenderRunner.PumpAsync: CR and LF both end a line.</summary> /// <summary>Mirrors BlenderRunner.PumpAsync: CR and LF both end a line.</summary>
private static List<string> SplitLikeThePump(string text) private static List<string> SplitLikeThePump(string text)
{ {
@@ -238,4 +238,104 @@ public class DeliveryStageTests : IDisposable
Assert.True(second.Ok); Assert.True(second.Ok);
} }
[Fact]
public async Task NoClientCodeKeepsTheInternalRenderFilenames()
{
// Regression pin: DeliveredBaseName defaults to "" for a shot with no
// client code, and delivery must render byte-identical to before this
// feature existed.
WriteFrames(2);
var manifest = Manifest(fileCount: 2);
Assert.Equal("", manifest.Items[0].DeliveredBaseName);
var result = await NewStage().RunAsync(new ClaimedJob { Id = "job1" }, manifest, "machine1",
CancellationToken.None, CancellationToken.None);
Assert.True(result.Ok);
Assert.True(File.Exists(Path.Combine(_packageDir, "SHOT_001", "SHOT_001_cmp_TT_v001.01001.exr")));
Assert.True(File.Exists(Path.Combine(_packageDir, "SHOT_001", "SHOT_001_cmp_TT_v001.01002.exr")));
}
[Fact]
public async Task ClientCodeRenamesDeliveredFramesPreservingNumberAndPadding()
{
WriteFrames(3, startFrame: 1001);
var manifest = Manifest(fileCount: 3);
manifest.Items[0].DeliveredBaseName = "SNV_101_0461_CP_CAMF_PL_v001";
var result = await NewStage().RunAsync(new ClaimedJob { Id = "job1" }, manifest, "machine1",
CancellationToken.None, CancellationToken.None);
Assert.True(result.Ok);
var deliveredDir = Path.Combine(_packageDir, "SHOT_001");
Assert.True(File.Exists(Path.Combine(deliveredDir, "SNV_101_0461_CP_CAMF_PL_v001.01001.exr")));
Assert.True(File.Exists(Path.Combine(deliveredDir, "SNV_101_0461_CP_CAMF_PL_v001.01002.exr")));
Assert.True(File.Exists(Path.Combine(deliveredDir, "SNV_101_0461_CP_CAMF_PL_v001.01003.exr")));
// The internal shotCode-based name must not leak into the delivery.
Assert.False(File.Exists(Path.Combine(deliveredDir, "SHOT_001_cmp_TT_v001.01001.exr")));
Assert.Equal(3, Directory.GetFiles(deliveredDir, "*.exr").Length);
}
[Fact]
public async Task ClientCodeRenamesTheDeliveryMov()
{
WriteFrames(2);
var movSrc = Path.Combine(_sourceDir, "SHOT_001_cmp_TT_v001.mov");
File.WriteAllText(movSrc, "mov bytes");
var manifest = Manifest(fileCount: 2);
manifest.IncludeMovs = true;
manifest.Items[0].DeliveryMovPath = movSrc;
manifest.Items[0].DeliveredBaseName = "SNV_101_0461_CP_CAMF_PL_v001";
var result = await NewStage().RunAsync(new ClaimedJob { Id = "job1" }, manifest, "machine1",
CancellationToken.None, CancellationToken.None);
Assert.True(result.Ok);
var deliveredDir = Path.Combine(_packageDir, "SHOT_001");
Assert.True(File.Exists(Path.Combine(deliveredDir, "SNV_101_0461_CP_CAMF_PL_v001.mov")));
Assert.Equal(Path.Combine(deliveredDir, "SNV_101_0461_CP_CAMF_PL_v001.mov"), result.Items[0].MovPath);
}
[Fact]
public async Task ClientCodeRenameStillVerifiesAgainstTheValidationTimeChecksum()
{
// Renaming must not change file *content*, so a checksum recorded at
// validation time (against the internal name) has to still match the
// delivered (renamed) files — the hash is content-based, not name-based.
WriteFrames(3);
var manifest = Manifest(copyMode: "always-copy");
manifest.Items[0].DeliveredBaseName = "SNV_101_0461_CP_CAMF_PL_v001";
var first = await NewStage().RunAsync(new ClaimedJob { Id = "job1" }, manifest, "machine1",
CancellationToken.None, CancellationToken.None);
Assert.True(first.Ok);
Directory.Delete(_packageDir, recursive: true);
var replay = Manifest(checksum: first.Items[0].Checksum, copyMode: "always-copy");
replay.Items[0].DeliveredBaseName = "SNV_101_0461_CP_CAMF_PL_v001";
var second = await NewStage().RunAsync(new ClaimedJob { Id = "job1" }, replay, "machine1",
CancellationToken.None, CancellationToken.None);
Assert.True(second.Ok);
}
[Fact]
public async Task UnparseableFrameNumberFallsBackToTheSourceFilename()
{
// A file that doesn't match the render's own numbering convention
// (shouldn't happen for a real render, but must never crash a delivery)
// is delivered under its original name rather than failing the item.
Directory.CreateDirectory(_sourceDir);
File.WriteAllText(Path.Combine(_sourceDir, "SHOT_001_cmp_TT_v001_no_frame_number.exr"), "junk");
var manifest = Manifest(fileCount: 1);
manifest.Items[0].OutputPattern = "SHOT_001_cmp_TT_v001_no_frame_number.exr";
manifest.Items[0].DeliveredBaseName = "SNV_101_0461_CP_CAMF_PL_v001";
var result = await NewStage().RunAsync(new ClaimedJob { Id = "job1" }, manifest, "machine1",
CancellationToken.None, CancellationToken.None);
Assert.True(result.Ok);
Assert.True(File.Exists(Path.Combine(_packageDir, "SHOT_001", "SHOT_001_cmp_TT_v001_no_frame_number.exr")));
}
} }
@@ -0,0 +1,193 @@
using Microsoft.Extensions.Logging.Abstractions;
using VFXReviewWorker;
using Xunit;
namespace VFXReviewWorker.Tests;
/// <summary>
/// MOV review packages (RenderPipeline2 §11.6). A review folder is opened
/// directly by a producer, so the things pinned here are the ones they would
/// notice: it is flat, it carries the client's own naming, and it contains the
/// MOVs and nothing else.
/// </summary>
public class MovReviewStageTests : IDisposable
{
private readonly string _root = Path.Combine(Path.GetTempPath(), $"vfxr_review_{Guid.NewGuid():N}");
private readonly string _renderDir;
private readonly string _reviewDir;
public MovReviewStageTests()
{
_renderDir = Path.Combine(_root, "renders", "SHOT_001", "v004");
_reviewDir = Path.Combine(_root, "DELIVERY", "PRODUCER_REVIEWS", "20260828_Producer_review");
Directory.CreateDirectory(_renderDir);
}
public void Dispose()
{
try { Directory.Delete(_root, recursive: true); } catch { }
}
private string WriteMov(string shotCode, string version, string contents = "mov bytes")
{
var path = Path.Combine(_renderDir, $"{shotCode}_cmp_TT_{version}.mov");
File.WriteAllText(path, contents);
return path;
}
private DeliveryManifest Manifest(params DeliveryManifestItem[] items) => new()
{
Kind = "MOV_REVIEW",
PackageId = "pkg1",
PackageName = "20260828_Producer_review",
PackageNumber = 7,
Episode = "101",
PackageDir = _reviewDir,
// A review writes no report; the server keeps the record instead.
ReportFile = "",
Items = items.ToList(),
};
private DeliveryManifestItem Item(
string shotCode, string version, string? movPath, string? deliveredBase = null) => new()
{
ItemId = $"item_{shotCode}",
ExportId = $"exp_{shotCode}",
ShotCode = shotCode,
VersionString = version,
SourceDir = "",
OutputPattern = "",
FrameStart = 1001,
FrameEnd = 1050,
DeliveryMovPath = movPath,
// Flat: every item's folder is the package folder itself.
ShotDir = _reviewDir,
DeliveredBaseName = deliveredBase ?? $"{shotCode}_cmp_TT_{version}",
};
private DeliveryStage NewStage() => new(
new WorkerOptions { ServerUrl = "n/a", ApiKey = "n/a" },
new ApiClient(new WorkerOptions { ServerUrl = "http://localhost:1", ApiKey = "x" }, NullLogger<ApiClient>.Instance),
NullLogger<DeliveryStage>.Instance);
[Fact]
public async Task BuildsAFlatFolderOfMovsUnderTheClientFacingName()
{
var mov = WriteMov("SHOT_001", "v004");
var manifest = Manifest(Item("SHOT_001", "v004", mov, deliveredBase: "EP6_VFX_012_v004"));
var result = await NewStage().RunAsync(new ClaimedJob { Id = "job1" }, manifest, "machine1",
CancellationToken.None, CancellationToken.None);
Assert.True(result.Ok);
var item = Assert.Single(result.Items);
Assert.Equal("VERIFIED", item.Status);
Assert.Equal(1, item.FileCount);
// No shot subfolder: the MOVs sit beside each other to be scrubbed through.
Assert.Null(item.ExrPath);
Assert.Equal(Path.Combine(_reviewDir, "EP6_VFX_012_v004.mov"), item.MovPath);
Assert.Single(Directory.GetDirectories(_reviewDir).Concat(Directory.GetFiles(_reviewDir)));
}
[Fact]
public async Task LeavesNoReportOrManifestBesideTheMovs()
{
var manifest = Manifest(Item("SHOT_001", "v004", WriteMov("SHOT_001", "v004")));
var result = await NewStage().RunAsync(new ClaimedJob { Id = "job1" }, manifest, "machine1",
CancellationToken.None, CancellationToken.None);
Assert.True(result.Ok);
Assert.Null(result.ReportPath);
// What a producer opens is exactly the MOVs — no manifest.json, no CSV.
Assert.False(File.Exists(Path.Combine(_reviewDir, "manifest.json")));
Assert.All(Directory.GetFiles(_reviewDir), f => Assert.EndsWith(".mov", f));
}
[Fact]
public async Task HardLinksSoASeventyShotReviewCostsNoDisk()
{
var mov = WriteMov("SHOT_001", "v004");
var manifest = Manifest(Item("SHOT_001", "v004", mov));
var result = await NewStage().RunAsync(new ClaimedJob { Id = "job1" }, manifest, "machine1",
CancellationToken.None, CancellationToken.None);
Assert.Equal("hardlink", result.Items[0].LinkMode);
File.WriteAllText(mov, "rewritten");
Assert.Equal("rewritten", File.ReadAllText(result.Items[0].MovPath!));
}
[Fact]
public async Task AlwaysCopyModeProducesAnIndependentFile()
{
var mov = WriteMov("SHOT_001", "v004");
var manifest = Manifest(Item("SHOT_001", "v004", mov));
manifest.CopyMode = "always-copy";
var result = await NewStage().RunAsync(new ClaimedJob { Id = "job1" }, manifest, "machine1",
CancellationToken.None, CancellationToken.None);
Assert.True(result.Ok);
Assert.Equal("copy", result.Items[0].LinkMode);
File.WriteAllText(mov, "rewritten");
Assert.NotEqual("rewritten", File.ReadAllText(result.Items[0].MovPath!));
}
[Fact]
public async Task AMissingMovFailsTheReviewRatherThanShippingItShort()
{
// In an EXR delivery a missing MOV is a missing viewing copy and the
// package continues. In a review the MOV *is* the deliverable.
var manifest = Manifest(Item("SHOT_001", "v004", Path.Combine(_renderDir, "never_rendered.mov")));
var result = await NewStage().RunAsync(new ClaimedJob { Id = "job1" }, manifest, "machine1",
CancellationToken.None, CancellationToken.None);
Assert.False(result.Ok);
Assert.Equal("FAILED", result.Items[0].Status);
Assert.Contains("Preview MOV not found", result.Items[0].ErrorMessage!);
}
[Fact]
public async Task AnItemWithNoRecordedMovFails()
{
var manifest = Manifest(Item("SHOT_001", "v004", null));
var result = await NewStage().RunAsync(new ClaimedJob { Id = "job1" }, manifest, "machine1",
CancellationToken.None, CancellationToken.None);
Assert.False(result.Ok);
Assert.Contains("No preview MOV", result.Items[0].ErrorMessage!);
}
[Fact]
public async Task HashesEveryFileWhenTheConfigDemandsIt()
{
var manifest = Manifest(Item("SHOT_001", "v004", WriteMov("SHOT_001", "v004")));
manifest.VerifyMode = "always-hash";
var result = await NewStage().RunAsync(new ClaimedJob { Id = "job1" }, manifest, "machine1",
CancellationToken.None, CancellationToken.None);
Assert.True(result.Ok);
// A MOV has no validation-time digest of its own, so the one recorded
// here is the one this build computed.
Assert.False(string.IsNullOrWhiteSpace(result.Items[0].Checksum));
}
[Fact]
public async Task OneBadShotFailsThePackageAndTheRestStillReport()
{
var manifest = Manifest(
Item("SHOT_001", "v004", WriteMov("SHOT_001", "v004")),
Item("SHOT_002", "v002", Path.Combine(_renderDir, "absent.mov")));
var result = await NewStage().RunAsync(new ClaimedJob { Id = "job1" }, manifest, "machine1",
CancellationToken.None, CancellationToken.None);
Assert.False(result.Ok);
Assert.Equal("VERIFIED", result.Items[0].Status);
Assert.Equal("FAILED", result.Items[1].Status);
}
}
@@ -0,0 +1,205 @@
using System.Collections.Concurrent;
using System.Net;
using System.Net.Sockets;
using System.Text.Json;
using Microsoft.Extensions.Logging.Abstractions;
using VFXReviewWorker;
using Xunit;
namespace VFXReviewWorker.Tests;
/// <summary>
/// Large artifacts go up as parallel multipart parts: from the studio a single
/// connection to object storage is capped near 0.1 MB/s, so a ProRes MOV could
/// not finish inside the 30 min request timeout. These drive the real upload
/// code against a local fake of the server + storage.
/// </summary>
public class MultipartUploadTests : IDisposable
{
private const int PartSize = 8 * 1024 * 1024;
private readonly HttpListener _listener = new();
private readonly string _base;
private readonly ConcurrentDictionary<int, byte[]> _parts = new();
private readonly ConcurrentDictionary<int, int> _failuresLeft = new();
private readonly ConcurrentBag<string> _completions = new();
private int _inFlight, _maxInFlight;
private bool _multipartSupported = true;
private byte[]? _singlePut;
public MultipartUploadTests()
{
var port = FreePort();
_base = $"http://localhost:{port}/";
_listener.Prefixes.Add(_base);
_listener.Start();
_ = Task.Run(Serve);
}
private static int FreePort()
{
var l = new TcpListener(IPAddress.Loopback, 0);
l.Start();
var port = ((IPEndPoint)l.LocalEndpoint).Port;
l.Stop();
return port;
}
private async Task Serve()
{
while (_listener.IsListening)
{
HttpListenerContext ctx;
try { ctx = await _listener.GetContextAsync(); } catch { return; }
_ = Task.Run(() => Handle(ctx));
}
}
private async Task Handle(HttpListenerContext ctx)
{
var path = ctx.Request.Url!.AbsolutePath;
using var ms = new MemoryStream();
await ctx.Request.InputStream.CopyToAsync(ms);
var body = ms.ToArray();
var res = ctx.Response;
if (path.EndsWith("/artifact-presign"))
{
var req = JsonDocument.Parse(body).RootElement;
var size = req.GetProperty("size").GetInt64();
object payload = _multipartSupported && req.GetProperty("multipart").GetBoolean()
? new
{
key = "highres/x.mov",
uploadId = "up1",
partSize = PartSize,
partUrls = Enumerable.Range(1, (int)((size + PartSize - 1) / PartSize))
.Select(n => $"{_base}part/{n}").ToList(),
}
: new { key = "highres/x.mov", presignedUrl = $"{_base}single" };
await Json(res, payload);
}
else if (path.StartsWith("/part/"))
{
var n = int.Parse(path["/part/".Length..]);
var now = Interlocked.Increment(ref _inFlight);
InterlockedMax(ref _maxInFlight, now);
await Task.Delay(50);
Interlocked.Decrement(ref _inFlight);
if (_failuresLeft.TryGetValue(n, out var left) && left > 0)
{
_failuresLeft[n] = left - 1;
res.StatusCode = 500;
res.Close();
return;
}
_parts[n] = body;
res.Headers["ETag"] = $"\"etag-{n}\"";
res.Close();
}
else if (path == "/single")
{
_singlePut = body;
res.Close();
}
else if (path.EndsWith("/artifact-complete"))
{
_completions.Add(System.Text.Encoding.UTF8.GetString(body));
await Json(res, new { ok = true });
}
else
{
res.StatusCode = 404;
res.Close();
}
}
private static void InterlockedMax(ref int target, int value)
{
int seen;
while ((seen = Volatile.Read(ref target)) < value && Interlocked.CompareExchange(ref target, value, seen) != seen) { }
}
private static async Task Json(HttpListenerResponse res, object payload)
{
var bytes = JsonSerializer.SerializeToUtf8Bytes(payload, WorkerOptions.JsonOpts);
res.ContentType = "application/json";
await res.OutputStream.WriteAsync(bytes);
res.Close();
}
private ApiClient Client(int concurrency = 4) =>
new(new WorkerOptions { ServerUrl = _base, ApiKey = "k", UploadConcurrency = concurrency },
NullLogger<ApiClient>.Instance);
private static string TempFile(int bytes)
{
var path = Path.GetTempFileName();
var data = new byte[bytes];
new Random(42).NextBytes(data);
File.WriteAllBytes(path, data);
return path;
}
[Fact]
public async Task Uploads_parts_in_parallel_and_stitches_them_in_order()
{
var file = TempFile(PartSize * 5 + 12345);
long lastProgress = 0;
var key = await Client(4).UploadArtifactAsync("job1", "m1", "highres", file, "video/quicktime",
CancellationToken.None, sent => Interlocked.Exchange(ref lastProgress, sent));
Assert.Equal("highres/x.mov", key);
var stitched = Enumerable.Range(1, 6).SelectMany(n => _parts[n]).ToArray();
Assert.Equal(File.ReadAllBytes(file), stitched);
Assert.True(_maxInFlight > 1, "parts should upload concurrently");
Assert.True(_maxInFlight <= 4, "concurrency is capped by UploadConcurrency");
Assert.Equal(new FileInfo(file).Length, Interlocked.Read(ref lastProgress));
var complete = JsonDocument.Parse(Assert.Single(_completions)).RootElement;
Assert.False(complete.TryGetProperty("abort", out _));
Assert.Equal(6, complete.GetProperty("parts").GetArrayLength());
Assert.Equal("\"etag-1\"", complete.GetProperty("parts")[0].GetProperty("etag").GetString());
File.Delete(file);
}
[Fact]
public async Task A_failed_part_is_retried_on_its_own()
{
var file = TempFile(PartSize * 3);
_failuresLeft[2] = 2;
var key = await Client().UploadArtifactAsync("job1", "m1", "highres", file, "video/quicktime", CancellationToken.None);
Assert.NotNull(key);
Assert.Equal(File.ReadAllBytes(file), Enumerable.Range(1, 3).SelectMany(n => _parts[n]).ToArray());
File.Delete(file);
}
[Fact]
public async Task A_part_that_keeps_failing_aborts_the_upload()
{
var file = TempFile(PartSize * 3);
_failuresLeft[3] = 99;
var key = await Client().UploadArtifactAsync("job1", "m1", "highres", file, "video/quicktime", CancellationToken.None);
Assert.Null(key);
var abort = JsonDocument.Parse(Assert.Single(_completions)).RootElement;
Assert.True(abort.GetProperty("abort").GetBoolean());
File.Delete(file);
}
[Fact]
public async Task Falls_back_to_a_single_put_on_a_server_without_multipart()
{
_multipartSupported = false;
var file = TempFile(PartSize * 3);
var key = await Client().UploadArtifactAsync("job1", "m1", "highres", file, "video/quicktime", CancellationToken.None);
Assert.Equal("highres/x.mov", key);
Assert.Equal(File.ReadAllBytes(file), _singlePut);
Assert.Empty(_completions);
File.Delete(file);
}
public void Dispose() => _listener.Close();
}
@@ -70,6 +70,59 @@ public class PrepareOutputDirTests
} }
} }
/// <summary>
/// The version folder holds the preview MOV/MP4 built from the same
/// basename. A shot re-rendered at the same version — the "No preview"
/// workflow, where the EXRs are re-exported unscaled and the earlier MOV is
/// inherited as the review media — must not have that MOV cleared out from
/// under it before aerender starts.
/// </summary>
[Fact]
public void KeepsPreviewMediaSharingThePatternPrefix()
{
var dir = Path.Combine(Path.GetTempPath(), "vfxr-test-" + Guid.NewGuid().ToString("N"));
Directory.CreateDirectory(dir);
try
{
File.WriteAllText(Path.Combine(dir, "SHOT_cmp_TT_v004.1001.exr"), "old");
File.WriteAllText(Path.Combine(dir, "SHOT_cmp_TT_v004.mov"), "delivery mov");
File.WriteAllText(Path.Combine(dir, "SHOT_cmp_TT_v004.mp4"), "review mp4");
AerenderRunner.PrepareOutputDir(dir, "SHOT_cmp_TT_v004.[####].exr");
Assert.False(File.Exists(Path.Combine(dir, "SHOT_cmp_TT_v004.1001.exr")));
Assert.True(File.Exists(Path.Combine(dir, "SHOT_cmp_TT_v004.mov")));
Assert.True(File.Exists(Path.Combine(dir, "SHOT_cmp_TT_v004.mp4")));
}
finally
{
Directory.Delete(dir, recursive: true);
}
}
[Fact]
public void ClearsOnlyThisVersionsFrames()
{
var dir = Path.Combine(Path.GetTempPath(), "vfxr-test-" + Guid.NewGuid().ToString("N"));
Directory.CreateDirectory(dir);
try
{
File.WriteAllText(Path.Combine(dir, "SHOT_cmp_TT_v004.1001.exr"), "old");
File.WriteAllText(Path.Combine(dir, "SHOT_cmp_TT_v005.1001.exr"), "other version");
File.WriteAllText(Path.Combine(dir, "OTHERSHOT_cmp_TT_v004.1001.exr"), "other shot");
AerenderRunner.PrepareOutputDir(dir, "SHOT_cmp_TT_v004.[####].exr");
Assert.False(File.Exists(Path.Combine(dir, "SHOT_cmp_TT_v004.1001.exr")));
Assert.True(File.Exists(Path.Combine(dir, "SHOT_cmp_TT_v005.1001.exr")));
Assert.True(File.Exists(Path.Combine(dir, "OTHERSHOT_cmp_TT_v004.1001.exr")));
}
finally
{
Directory.Delete(dir, recursive: true);
}
}
[Fact] [Fact]
public void CreatesMissingDirectory() public void CreatesMissingDirectory()
{ {
@@ -117,4 +117,21 @@ public class LogTailTests
for (var i = 1; i <= 5; i++) tail.Add($"line {i}"); for (var i = 1; i <= 5; i++) tail.Add($"line {i}");
Assert.Equal("line 3\nline 4\nline 5", tail.ToString()); Assert.Equal("line 3\nline 4\nline 5", tail.ToString());
} }
[Fact]
public async Task ReadingWhileAnotherThreadWritesDoesNotThrow()
{
// The Blender runner's output pumps add lines while its progress loop
// reads the tail; unsynchronised this threw "Collection was modified".
var tail = new LogTail(200);
using var stop = new CancellationTokenSource(TimeSpan.FromSeconds(1));
var writer = Task.Run(() =>
{
var i = 0;
while (!stop.IsCancellationRequested) tail.Add($"Fra:1001 Sample {i++}/128");
});
while (!stop.IsCancellationRequested) _ = tail.ToString();
await writer;
}
} }
@@ -0,0 +1,54 @@
using VFXReviewWorker;
using Xunit;
namespace VFXReviewWorker.Tests;
/// <summary>
/// The preview MP4 opens on the Netflix slate. ffmpeg's <c>thumbnail</c> filter
/// only considers the first 100 frames, so every thumbnail the pipeline has ever
/// produced was a picture of the slate card rather than of the shot — invisible
/// while thumbnails were only decoration in the QC queue, and unacceptable now
/// they can become a shot's thumbnail.
///
/// The fix is to seek past the slate, so the seek arithmetic is worth pinning.
/// </summary>
public class ThumbnailSeekTests
{
private static PreviewBuildResult Build(double? pictureStart, int? frameCount) =>
new() { PictureStartSeconds = pictureStart, FrameCount = frameCount };
[Fact]
public void SeeksAQuarterIntoPictureNotIntoTheFile()
{
// 5s slate, then 96 frames (4s) of picture at 24fps → 5 + 1 = 6s.
var seek = PreviewStage.ThumbnailSeekSeconds(Build(5.0, 96), 24);
Assert.NotNull(seek);
Assert.Equal(6.0, seek!.Value, 3);
}
[Fact]
public void HandlesATemplateWithNoSlateAtAll()
{
var seek = PreviewStage.ThumbnailSeekSeconds(Build(0.0, 240), 24);
Assert.Equal(2.5, seek!.Value, 3);
}
[Fact]
public void FallsBackWhenTheBuildDidNotReportWherePictureStarts()
{
// Older worker, or a template with no SHOT layer: null means "keep the
// old whole-file behaviour" rather than guessing an offset.
Assert.Null(PreviewStage.ThumbnailSeekSeconds(Build(null, 96), 24));
Assert.Null(PreviewStage.ThumbnailSeekSeconds(null, 24));
}
[Theory]
[InlineData(-1.0, 96, 24)] // negative slate length
[InlineData(5.0, 0, 24)] // no picture frames
[InlineData(5.0, -5, 24)] // nonsense frame count
[InlineData(5.0, 96, 0)] // no fps to divide by
public void RefusesNumbersThatDoNotDescribeARealClip(double start, int frames, double fps)
{
Assert.Null(PreviewStage.ThumbnailSeekSeconds(Build(start, frames), fps));
}
}
@@ -109,6 +109,74 @@ public class ValidationStageTests : IDisposable
Assert.Contains("8-frame handle", tc.Message); Assert.Contains("8-frame handle", tc.Message);
} }
/// <summary>Writes a one-frame plate into a footage-style element folder.</summary>
private string WritePlate(string element, string timecode, int fps = 24)
{
var plate = Path.Combine(_dir, "footage", $"UNG_107_051_010_{element}_TT_v001", $"UNG_107_051_010_{element}_TT_v001.01001.exr");
Directory.CreateDirectory(Path.GetDirectoryName(plate)!);
File.Move(ExrFixture.Write(timecode, 3840, 2160, new[] { ("B", 1), ("G", 1), ("R", 1) }, fps, 4), plate);
return plate;
}
private static ManifestSource Source(string timingPlate, params string[] plates) => new()
{
TimingPlate = new PlateRef { Path = timingPlate, FrameStart = 1001 },
Plates = plates.Select(p => new PlateRef { Path = p, FrameStart = 1001 }).ToList(),
HandleFrames = 8,
};
[Fact]
public void AnotherDeliveredPlatePassesWhenTheTimingPlateDoesNot()
{
// The comp was anchored to FG01, but the panel named BG01 (longest) as
// the timing plate — the two carry unrelated camera timecodes.
WriteSequence(105, "09:12:00:00");
var bg = WritePlate("BG01", "14:26:31:08");
var fg = WritePlate("FG01", "09:12:00:00");
var manifest = Manifest(_dir, null, 1001);
manifest.Source = Source(bg, bg, fg);
var tc = Check(NewStage().Run(manifest, _dir, new ServerConfig()), "timecode_plate_match");
Assert.Equal("PASS", tc.Status);
Assert.Contains("UNG_107_051_010_FG01_TT_v001.01001.exr", tc.Message);
Assert.Contains("BG01", tc.Message);
}
[Fact]
public void NoMatchingPlateStillFailsAgainstTheTimingPlate()
{
WriteSequence(105, "14:26:31:16");
var bg = WritePlate("BG01", "14:26:31:08");
var fg = WritePlate("FG01", "09:12:00:00");
var manifest = Manifest(_dir, null, 1001);
manifest.Source = Source(bg, bg, fg);
var tc = Check(NewStage().Run(manifest, _dir, new ServerConfig()), "timecode_plate_match");
Assert.Equal("FAIL", tc.Status);
Assert.Equal("14:26:31:08", tc.Expected);
Assert.Contains("8-frame handle", tc.Message);
Assert.Contains("1 other delivered plate", tc.Message);
}
[Fact]
public void APreRenderIsNeverUsedAsTheFallbackPlate()
{
// plates[] is every file in the comp. A pre-render was rendered from
// this comp, so it agrees with the render whether or not either is right.
WriteSequence(105, "14:26:31:16");
var bg = WritePlate("BG01", "14:26:31:08");
var preRender = Path.Combine(_dir, "renders", "prerender", "UNG_107_051_010_PRERENDER_01001.exr");
Directory.CreateDirectory(Path.GetDirectoryName(preRender)!);
File.Move(ExrFixture.Write("14:26:31:16", 3840, 2160, new[] { ("B", 1), ("G", 1), ("R", 1) }, 24, 4), preRender);
var manifest = Manifest(_dir, null, 1001);
manifest.Source = Source(bg, bg, preRender);
Assert.Equal("FAIL", Check(NewStage().Run(manifest, _dir, new ServerConfig()), "timecode_plate_match").Status);
}
[Fact] [Fact]
public void APlateAtADifferentRateFailsPlateFps() public void APlateAtADifferentRateFailsPlateFps()
{ {
+34 -16
View File
@@ -234,26 +234,30 @@ public sealed class AerenderRunner
} }
/// <summary> /// <summary>
/// §7.3: outputDir is created before launch; a pre-existing non-empty dir /// §7.3: outputDir is created before launch; a pre-existing dir can hold
/// can only hold output from a previous crashed attempt of this same /// frames from a previous crashed attempt, which aerender would otherwise
/// immutable version. Safety guard: only files matching the job's own /// leave interleaved with this attempt's. Safety guard: only files matching
/// output pattern prefix are ever deleted. /// the job's own output pattern — its prefix *and* its extension — are ever
/// deleted.
///
/// The extension is not optional. The version folder is shared with the
/// preview stage, whose MOV and MP4 are built from the same basename
/// (preview.ts: `{outputDir}/{base}.mov`), so prefix alone also matches
/// them. A version folder can legitimately be rendered into twice — the
/// output path is keyed on the shot's manually-set version, not on the
/// export — and on a no-preview re-render (Export.skipPreview) the media
/// that gets inherited is precisely the MOV sitting in this folder.
/// Deleting it left the export pointing at a file that no longer existed,
/// and delivery silently packaged the EXRs without their viewing copy.
/// </summary> /// </summary>
/// <summary>Filename prefix of an output pattern ("X.[####].exr" → "X").</summary>
internal static string OutputPatternPrefix(string outputPattern)
{
var bracket = outputPattern.IndexOf('[');
return bracket > 0 ? outputPattern[..bracket].TrimEnd('.') : Path.GetFileNameWithoutExtension(outputPattern);
}
internal static void PrepareOutputDir(string outputDirLocal, string outputPattern) internal static void PrepareOutputDir(string outputDirLocal, string outputPattern)
{ {
Directory.CreateDirectory(outputDirLocal); Directory.CreateDirectory(outputDirLocal);
var prefix = OutputPatternPrefix(outputPattern); var pattern = SequencePattern.FromOutputPattern(outputPattern);
if (string.IsNullOrEmpty(prefix)) return; if (string.IsNullOrEmpty(pattern.Prefix)) return;
foreach (var file in Directory.EnumerateFiles(outputDirLocal)) foreach (var file in Directory.EnumerateFiles(outputDirLocal))
{ {
if (Path.GetFileName(file).StartsWith(prefix, StringComparison.OrdinalIgnoreCase)) if (pattern.MatchesOutputFile(Path.GetFileName(file)))
{ {
try { File.Delete(file); } catch { /* locked leftovers surface as an aerender error */ } try { File.Delete(file); } catch { /* locked leftovers surface as an aerender error */ }
} }
@@ -276,11 +280,19 @@ public sealed class AerenderRunner
} }
} }
/// <summary>Ring buffer of the last N output lines (§5.3 logTail).</summary> /// <summary>
/// Ring buffer of the last N output lines (§5.3 logTail).
///
/// Thread-safe: output readers add lines while the progress loop reads the
/// tail for its report. Unsynchronised, ToString enumerates the queue while a
/// reader enqueues and throws "Collection was modified" — Blender, which
/// writes a status line many times a second, hit this on every job.
/// </summary>
public sealed class LogTail public sealed class LogTail
{ {
private readonly Queue<string> _lines; private readonly Queue<string> _lines;
private readonly int _capacity; private readonly int _capacity;
private readonly object _gate = new();
public LogTail(int capacity) public LogTail(int capacity)
{ {
@@ -289,10 +301,16 @@ public sealed class LogTail
} }
public void Add(string line) public void Add(string line)
{
lock (_gate)
{ {
_lines.Enqueue(line); _lines.Enqueue(line);
while (_lines.Count > _capacity) _lines.Dequeue(); while (_lines.Count > _capacity) _lines.Dequeue();
} }
}
public override string ToString() => string.Join('\n', _lines); public override string ToString()
{
lock (_gate) return string.Join('\n', _lines);
}
} }
+148 -10
View File
@@ -13,10 +13,16 @@ namespace VFXReviewWorker;
public sealed class ApiClient public sealed class ApiClient
{ {
private readonly HttpClient _http; private readonly HttpClient _http;
private readonly WorkerOptions _options;
private readonly ILogger<ApiClient> _log; private readonly ILogger<ApiClient> _log;
// Presigned uploads: a separate client so the URL is not sent with our
// Authorization header, and a generous per-request timeout for media.
private static readonly HttpClient _upload = new() { Timeout = TimeSpan.FromMinutes(30) };
public ApiClient(WorkerOptions options, ILogger<ApiClient> log) public ApiClient(WorkerOptions options, ILogger<ApiClient> log)
{ {
_options = options;
_log = log; _log = log;
_http = new HttpClient _http = new HttpClient
{ {
@@ -124,6 +130,7 @@ public sealed class ApiClient
"validation" => $"api/ext/render/jobs/{jobId}/validation", "validation" => $"api/ext/render/jobs/{jobId}/validation",
"delivery" => $"api/ext/render/jobs/{jobId}/delivery", "delivery" => $"api/ext/render/jobs/{jobId}/delivery",
"finalize" => $"api/ext/render/jobs/{jobId}/finalize", "finalize" => $"api/ext/render/jobs/{jobId}/finalize",
"attach-highres" => $"api/ext/render/jobs/{jobId}/attach-highres",
_ => throw new ArgumentOutOfRangeException(nameof(kind), kind, "unknown lifecycle report kind"), _ => throw new ArgumentOutOfRangeException(nameof(kind), kind, "unknown lifecycle report kind"),
}; };
var res = await _http.PostAsJsonAsync(path, payload, Json, ct); var res = await _http.PostAsJsonAsync(path, payload, Json, ct);
@@ -143,8 +150,10 @@ public sealed class ApiClient
} }
// E20 + PUT upload. Returns the storage key, or null when the upload failed. // E20 + PUT upload. Returns the storage key, or null when the upload failed.
// onProgress receives the bytes sent so far, for status lines in the app.
public async Task<string?> UploadArtifactAsync( public async Task<string?> UploadArtifactAsync(
string jobId, string machineId, string kind, string filePath, string contentType, CancellationToken ct) string jobId, string machineId, string kind, string filePath, string contentType, CancellationToken ct,
Action<long>? onProgress = null)
{ {
try try
{ {
@@ -153,6 +162,13 @@ public sealed class ApiClient
_log.LogWarning("Artifact {Kind} not found at {Path}", kind, filePath); _log.LogWarning("Artifact {Kind} not found at {Path}", kind, filePath);
return null; return null;
} }
var size = new FileInfo(filePath).Length;
var sw = System.Diagnostics.Stopwatch.StartNew();
// Uploads can run for many minutes on a slow uplink; without these two
// lines the log goes silent and a busy worker looks hung.
if (kind != "log")
_log.LogInformation("Uploading {Kind} for job {JobId}: {File} ({MB:F1} MB)",
kind, jobId, Path.GetFileName(filePath), size / 1048576.0);
var presignRes = await _http.PostAsJsonAsync($"api/ext/render/jobs/{jobId}/artifact-presign", new var presignRes = await _http.PostAsJsonAsync($"api/ext/render/jobs/{jobId}/artifact-presign", new
{ {
@@ -160,6 +176,8 @@ public sealed class ApiClient
kind, kind,
fileName = Path.GetFileName(filePath), fileName = Path.GetFileName(filePath),
contentType, contentType,
multipart = size >= MultipartThreshold,
size,
}, Json, ct); }, Json, ct);
if (!presignRes.IsSuccessStatusCode) if (!presignRes.IsSuccessStatusCode)
{ {
@@ -169,18 +187,27 @@ public sealed class ApiClient
var presign = await presignRes.Content.ReadFromJsonAsync<PresignResponse>(Json, ct); var presign = await presignRes.Content.ReadFromJsonAsync<PresignResponse>(Json, ct);
if (presign is null) return null; if (presign is null) return null;
// Media files can be large — generous timeout, separate client so the if (presign.UploadId is not null && presign.PartUrls is { Count: > 0 } && presign.PartSize > 0)
// presigned URL is not sent with our Authorization header.
using var upload = new HttpClient { Timeout = TimeSpan.FromMinutes(30) };
await using var stream = File.OpenRead(filePath);
var content = new StreamContent(stream);
content.Headers.ContentType = new MediaTypeHeaderValue(contentType);
var putRes = await upload.PutAsync(presign.PresignedUrl, content, ct);
if (!putRes.IsSuccessStatusCode)
{ {
_log.LogWarning("Upload of {Kind} failed: {Status}", kind, (int)putRes.StatusCode); if (!await UploadMultipartAsync(jobId, machineId, kind, filePath, size, presign, onProgress, ct))
return null; return null;
} }
else
{
// Single PUT: small files, or a server that predates multipart.
await using var stream = File.OpenRead(filePath);
var content = new ProgressStreamContent(stream, onProgress);
content.Headers.ContentType = new MediaTypeHeaderValue(contentType);
var putRes = await _upload.PutAsync(presign.PresignedUrl, content, ct);
if (!putRes.IsSuccessStatusCode)
{
_log.LogWarning("Upload of {Kind} failed after {Sec:F0}s: {Status}", kind, sw.Elapsed.TotalSeconds, (int)putRes.StatusCode);
return null;
}
}
if (kind != "log")
_log.LogInformation("Uploaded {Kind} for job {JobId} in {Sec:F0}s ({Speed:F1} MB/s)",
kind, jobId, sw.Elapsed.TotalSeconds, size / 1048576.0 / Math.Max(0.001, sw.Elapsed.TotalSeconds));
return presign.Key; return presign.Key;
} }
catch (Exception ex) catch (Exception ex)
@@ -190,6 +217,117 @@ public sealed class ApiClient
} }
} }
// Files at least this big go up as parallel multipart parts (E20b).
private const long MultipartThreshold = 16L * 1024 * 1024;
private const int PartAttempts = 4;
/// <summary>
/// Uploads the parts concurrently (UploadConcurrency connections), each
/// retried on its own so a dropped connection costs one part, not the
/// file; then asks the server to stitch them. Aborts on failure so the
/// stored parts don't linger in the bucket.
/// </summary>
private async Task<bool> UploadMultipartAsync(string jobId, string machineId, string kind, string filePath,
long size, PresignResponse presign, Action<long>? onProgress, CancellationToken ct)
{
var partUrls = presign.PartUrls!;
var partSize = presign.PartSize;
var etags = new string?[partUrls.Count];
var sentPerPart = new long[partUrls.Count];
long sentTotal = 0;
var next = -1;
using var handle = File.OpenHandle(filePath, FileMode.Open, FileAccess.Read, FileShare.Read, FileOptions.Asynchronous);
using var failed = CancellationTokenSource.CreateLinkedTokenSource(ct);
async Task Worker()
{
int i;
while ((i = Interlocked.Increment(ref next)) < partUrls.Count && !failed.IsCancellationRequested)
{
var offset = i * partSize;
var len = (int)Math.Min(partSize, size - offset);
var buffer = new byte[len];
var read = 0;
while (read < len) read += await RandomAccess.ReadAsync(handle, buffer.AsMemory(read), offset + read, failed.Token);
for (var attempt = 1; ; attempt++)
{
var part = i;
// Progress restarts from zero for a retried part.
Interlocked.Add(ref sentTotal, -Interlocked.Exchange(ref sentPerPart[part], 0));
var content = new ProgressStreamContent(new MemoryStream(buffer, writable: false), sent =>
{
var delta = sent - Interlocked.Exchange(ref sentPerPart[part], sent);
onProgress?.Invoke(Interlocked.Add(ref sentTotal, delta));
});
try
{
var res = await _upload.PutAsync(partUrls[i], content, failed.Token);
var etag = res.Headers.ETag?.Tag
?? (res.Headers.TryGetValues("ETag", out var v) ? v.FirstOrDefault() : null);
if (res.IsSuccessStatusCode && etag is not null)
{
etags[i] = etag;
break;
}
_log.LogWarning("Part {Part}/{Count} of {Kind} for job {JobId} failed: {Status} (attempt {N}/{Max})",
i + 1, partUrls.Count, kind, jobId, (int)res.StatusCode, attempt, PartAttempts);
}
catch (Exception ex) when (!failed.IsCancellationRequested)
{
_log.LogWarning("Part {Part}/{Count} of {Kind} for job {JobId} failed: {Error} (attempt {N}/{Max})",
i + 1, partUrls.Count, kind, jobId, ex.Message, attempt, PartAttempts);
}
if (attempt >= PartAttempts)
{
failed.Cancel(); // no point finishing the other parts
return;
}
await Task.Delay(TimeSpan.FromSeconds(5 * attempt), failed.Token);
}
}
}
var concurrency = Math.Clamp(_options.UploadConcurrency, 1, 64);
try
{
await Task.WhenAll(Enumerable.Range(0, Math.Min(concurrency, partUrls.Count)).Select(_ => Task.Run(Worker)));
}
catch (OperationCanceledException)
{
// a part gave up, or shutdown — either way the upload is aborted below
}
var complete = !failed.IsCancellationRequested && etags.All(e => e is not null);
if (complete)
{
var res = await _http.PostAsJsonAsync($"api/ext/render/jobs/{jobId}/artifact-complete", new
{
machineId,
key = presign.Key,
uploadId = presign.UploadId,
parts = etags.Select((etag, i) => new { partNumber = i + 1, etag }),
}, Json, ct);
if (res.IsSuccessStatusCode) return true;
_log.LogWarning("Completing multipart {Kind} for job {JobId} failed: {Status} {Body}",
kind, jobId, (int)res.StatusCode, await res.Content.ReadAsStringAsync(ct));
}
try
{
await _http.PostAsJsonAsync($"api/ext/render/jobs/{jobId}/artifact-complete", new
{
machineId,
key = presign.Key,
uploadId = presign.UploadId,
abort = true,
}, Json, CancellationToken.None);
}
catch { /* parts expire on their own */ }
return false;
}
public Task<string?> UploadLogAsync(string jobId, string machineId, string logFilePath, CancellationToken ct) => public Task<string?> UploadLogAsync(string jobId, string machineId, string logFilePath, CancellationToken ct) =>
UploadArtifactAsync(jobId, machineId, "log", logFilePath, "text/plain", ct); UploadArtifactAsync(jobId, machineId, "log", logFilePath, "text/plain", ct);
@@ -8,18 +8,36 @@ namespace VFXReviewWorker;
/// with "Saved: '...'". The saved lines are the reliable signal — a frame can /// with "Saved: '...'". The saved lines are the reliable signal — a frame can
/// be reported for a long time while it renders — so progress counts those and /// be reported for a long time while it renders — so progress counts those and
/// falls back to Fra: for a first sign of life. /// falls back to Fra: for a first sign of life.
///
/// Blender 5.x logs through CLOG, which prefixes every line with an elapsed
/// time and a category ("00:02.954 render | Saved: '...'") and
/// reports errors as "ERROR ..." rather than "Error: ...". The prefix is
/// stripped before matching, so both formats parse the same way.
/// </summary> /// </summary>
public static partial class BlenderProgressParser public static partial class BlenderProgressParser
{ {
[GeneratedRegex(@"^Fra:(\d+)", RegexOptions.Compiled)] [GeneratedRegex(@"^(?:\d+:)?\d{2}:\d{2}\.\d{3}\s+\S+\s*\| ?", RegexOptions.Compiled)]
private static partial Regex LogPrefix();
[GeneratedRegex(@"^Fra:\s*(\d+)", RegexOptions.Compiled)]
private static partial Regex FrameLine(); private static partial Regex FrameLine();
[GeneratedRegex(@"^Saved:\s*'(.+)'", RegexOptions.Compiled)] [GeneratedRegex(@"^Saved:\s*'(.+)'", RegexOptions.Compiled)]
private static partial Regex SavedLine(); private static partial Regex SavedLine();
[GeneratedRegex(@"^(Error|Warning): |^Error: ", RegexOptions.Compiled | RegexOptions.IgnoreCase)] // Errors only. Warnings are not failures, and add-ons print them on every
// launch ("Warning: add-on missing 'bl_info'"), so counting them made an
// add-on's complaint the reported reason for a failed render.
[GeneratedRegex(@"(?i:^Error: )|^(ERROR|FATAL) ", RegexOptions.Compiled)]
private static partial Regex ErrorLine(); private static partial Regex ErrorLine();
/// <summary>The line without Blender 5.x's "elapsed category | " prefix.</summary>
private static string Message(string line)
{
var m = LogPrefix().Match(line);
return m.Success ? line[m.Length..] : line;
}
/// <summary> /// <summary>
/// Failures that will repeat identically on another machine — a missing /// Failures that will repeat identically on another machine — a missing
/// file, an unknown scene, an unwritable output. Retrying these burns the /// file, an unknown scene, an unwritable output. Retrying these burns the
@@ -35,7 +53,9 @@ public static partial class BlenderProgressParser
"unknown scene", "unknown scene",
"scene not found", "scene not found",
"unable to create directory", "unable to create directory",
"couldn't create directory",
"cannot write file", "cannot write file",
"cannot save:",
"no camera", "no camera",
"python script fail", "python script fail",
"unknown argument", "unknown argument",
@@ -44,18 +64,18 @@ public static partial class BlenderProgressParser
/// <summary>The frame Blender is currently working on, or null.</summary> /// <summary>The frame Blender is currently working on, or null.</summary>
public static int? ParseFrame(string line) public static int? ParseFrame(string line)
{ {
var m = FrameLine().Match(line); var m = FrameLine().Match(Message(line));
return m.Success && int.TryParse(m.Groups[1].Value, out var f) ? f : null; return m.Success && int.TryParse(m.Groups[1].Value, out var f) ? f : null;
} }
/// <summary>The path of a frame Blender has just written, or null.</summary> /// <summary>The path of a frame Blender has just written, or null.</summary>
public static string? ParseSaved(string line) public static string? ParseSaved(string line)
{ {
var m = SavedLine().Match(line); var m = SavedLine().Match(Message(line));
return m.Success ? m.Groups[1].Value : null; return m.Success ? m.Groups[1].Value : null;
} }
public static bool IsErrorLine(string line) => ErrorLine().IsMatch(line); public static bool IsErrorLine(string line) => ErrorLine().IsMatch(Message(line));
public static bool IsNonRetryableError(string line) public static bool IsNonRetryableError(string line)
{ {
+19 -1
View File
@@ -190,6 +190,21 @@ public sealed class BlenderRunner
PumpAsync(process.StandardError, line => HandleLine(line, isStderr: true)), PumpAsync(process.StandardError, line => HandleLine(line, isStderr: true)),
}; };
try
{
return await MonitorAsync();
}
catch
{
// Disposing a Process does not end it: without this, any exception
// in the monitor loop leaves Blender rendering on the node,
// unsupervised, while the job is retried alongside it.
KillTree(process);
throw;
}
async Task<RenderResult> MonitorAsync()
{
while (!process.HasExited) while (!process.HasExited)
{ {
await Task.Delay(TimeSpan.FromSeconds(2), CancellationToken.None); await Task.Delay(TimeSpan.FromSeconds(2), CancellationToken.None);
@@ -253,13 +268,16 @@ public sealed class BlenderRunner
if (framesSaved == 0) if (framesSaved == 0)
{ {
return new RenderResult(false, 0, Retryable: false, return new RenderResult(false, 0, Retryable: false,
"Blender exited cleanly but saved no frames — check the output path and frame range in the .blend", firstError is not null
? $"Blender exited cleanly but saved no frames: {firstError}"
: "Blender exited cleanly but saved no frames — check the output path and frame range in the .blend",
tail.ToString(), fullLogPath, sw.Elapsed.TotalSeconds); tail.ToString(), fullLogPath, sw.Elapsed.TotalSeconds);
} }
_log.LogInformation("Job {JobId}: {Saved}/{Total} frames in {Sec:F0}s", jobId, framesSaved, totalFrames, sw.Elapsed.TotalSeconds); _log.LogInformation("Job {JobId}: {Saved}/{Total} frames in {Sec:F0}s", jobId, framesSaved, totalFrames, sw.Elapsed.TotalSeconds);
return new RenderResult(true, 0, true, null, tail.ToString(), fullLogPath, sw.Elapsed.TotalSeconds); return new RenderResult(true, 0, true, null, tail.ToString(), fullLogPath, sw.Elapsed.TotalSeconds);
} }
}
/// <summary> /// <summary>
/// Reads a stream treating both CR and LF as line terminators, so /// Reads a stream treating both CR and LF as line terminators, so
+158 -7
View File
@@ -11,6 +11,10 @@ namespace VFXReviewWorker;
/// hard-links (or copies) each shot's EXRs and delivery MOV into it, verifies /// hard-links (or copies) each shot's EXRs and delivery MOV into it, verifies
/// what it wrote, and leaves a manifest + CSV report beside the shots. /// what it wrote, and leaves a manifest + CSV report beside the shots.
/// ///
/// A MOV_REVIEW package (§11.6) runs the same path for a different shape: one
/// flat folder, one preview MOV per shot, and nothing written into it but the
/// MOVs themselves — it is shared with a producer, not filed as a delivery.
///
/// Hard links make an 18-shot EXR package near-instant and cost no extra disk. /// Hard links make an 18-shot EXR package near-instant and cost no extra disk.
/// They are safe here because rendered versions are immutable by pipeline /// They are safe here because rendered versions are immutable by pipeline
/// design — a new version is a new directory, nothing ever rewrites an EXR in /// design — a new version is a new directory, nothing ever rewrites an EXR in
@@ -38,9 +42,10 @@ public sealed class DeliveryStage
var manifestFiles = new List<object>(); var manifestFiles = new List<object>();
var alwaysCopy = string.Equals(manifest.CopyMode, "always-copy", StringComparison.OrdinalIgnoreCase); var alwaysCopy = string.Equals(manifest.CopyMode, "always-copy", StringComparison.OrdinalIgnoreCase);
var alwaysHash = string.Equals(manifest.VerifyMode, "always-hash", StringComparison.OrdinalIgnoreCase); var alwaysHash = string.Equals(manifest.VerifyMode, "always-hash", StringComparison.OrdinalIgnoreCase);
var isReview = string.Equals(manifest.Kind, "MOV_REVIEW", StringComparison.OrdinalIgnoreCase);
_log.LogInformation("Building delivery package {Name} ({Count} shots) at {Dir}", _log.LogInformation("Building {What} {Name} ({Count} shots) at {Dir}",
manifest.PackageName, manifest.Items.Count, packageDir); isReview ? "MOV review" : "delivery package", manifest.PackageName, manifest.Items.Count, packageDir);
Directory.CreateDirectory(packageDir); Directory.CreateDirectory(packageDir);
for (var i = 0; i < manifest.Items.Count; i++) for (var i = 0; i < manifest.Items.Count; i++)
@@ -51,7 +56,9 @@ public sealed class DeliveryStage
await _api.ProgressAsync(job.Id, machineId, (double)i / manifest.Items.Count, i, manifest.Items.Count, null, await _api.ProgressAsync(job.Id, machineId, (double)i / manifest.Items.Count, i, manifest.Items.Count, null,
$"Packaging {item.ShotCode} {item.VersionString} ({i + 1}/{manifest.Items.Count})", shutdown); $"Packaging {item.ShotCode} {item.VersionString} ({i + 1}/{manifest.Items.Count})", shutdown);
var result = BuildItem(item, mapper, alwaysCopy, alwaysHash, manifestFiles); var result = isReview
? BuildReviewItem(item, mapper, alwaysCopy, alwaysHash, manifestFiles)
: BuildItem(item, mapper, alwaysCopy, alwaysHash, manifestFiles);
results.Add(result); results.Add(result);
if (result.Status == "FAILED") if (result.Status == "FAILED")
{ {
@@ -63,7 +70,13 @@ public sealed class DeliveryStage
// The report is the client-facing document, so it is written even for a // The report is the client-facing document, so it is written even for a
// partial build — it is the fastest way to see what did and did not land. // partial build — it is the fastest way to see what did and did not land.
//
// A review folder gets neither: it is opened by a producer who wants the
// MOVs and nothing else. The manifest still travels back to the server,
// so the record of what was shared is kept without cluttering the share.
string? reportPath = null; string? reportPath = null;
if (!isReview)
{
try try
{ {
reportPath = WriteReport(manifest, results, mapper); reportPath = WriteReport(manifest, results, mapper);
@@ -73,6 +86,7 @@ public sealed class DeliveryStage
{ {
_log.LogWarning(ex, "Could not write delivery report/manifest for {Name}", manifest.PackageName); _log.LogWarning(ex, "Could not write delivery report/manifest for {Name}", manifest.PackageName);
} }
}
return new DeliveryResult(ok, results, packageDir, reportPath, manifestFiles); return new DeliveryResult(ok, results, packageDir, reportPath, manifestFiles);
} }
@@ -109,11 +123,18 @@ public sealed class DeliveryStage
Directory.CreateDirectory(shotDir); Directory.CreateDirectory(shotDir);
// Delivered names carry the client-facing base (or the studio's own
// convention when no client code is set), not the internal render
// filename — only the frame number and extension survive from the
// source. A frame whose number can't be parsed falls back to the
// source filename verbatim rather than failing the whole delivery.
var destNames = sources.ToDictionary(s => s, s => DeliveredFrameName(s, item, pattern));
long totalBytes = 0; long totalBytes = 0;
var usedCopy = false; var usedCopy = false;
foreach (var src in sources) foreach (var src in sources)
{ {
var dest = Path.Combine(shotDir, Path.GetFileName(src)); var dest = Path.Combine(shotDir, destNames[src]);
if (Place(src, dest, alwaysCopy, out var copied) is string placeError) if (Place(src, dest, alwaysCopy, out var copied) is string placeError)
{ {
return DeliveryItemResult.Failed(item, placeError); return DeliveryItemResult.Failed(item, placeError);
@@ -134,7 +155,7 @@ public sealed class DeliveryStage
if (usedCopy || alwaysHash) if (usedCopy || alwaysHash)
{ {
digest = SequenceChecksum(sources.Select(s => Path.Combine(shotDir, Path.GetFileName(s)))); digest = SequenceChecksum(sources.Select(s => Path.Combine(shotDir, destNames[s])));
if (item.Checksum is { Length: > 0 } && !string.Equals(digest, item.Checksum, StringComparison.OrdinalIgnoreCase)) if (item.Checksum is { Length: > 0 } && !string.Equals(digest, item.Checksum, StringComparison.OrdinalIgnoreCase))
{ {
return DeliveryItemResult.Failed(item, return DeliveryItemResult.Failed(item,
@@ -174,7 +195,10 @@ public sealed class DeliveryStage
var movSrc = mapper.Map(item.DeliveryMovPath!); var movSrc = mapper.Map(item.DeliveryMovPath!);
if (File.Exists(movSrc)) if (File.Exists(movSrc))
{ {
movDest = Path.Combine(shotDir, Path.GetFileName(movSrc)); var movName = string.IsNullOrWhiteSpace(item.DeliveredBaseName)
? Path.GetFileName(movSrc)
: item.DeliveredBaseName + Path.GetExtension(movSrc);
movDest = Path.Combine(shotDir, movName);
if (Place(movSrc, movDest, alwaysCopy, out var movCopied) is string movError) if (Place(movSrc, movDest, alwaysCopy, out var movCopied) is string movError)
{ {
return DeliveryItemResult.Failed(item, movError); return DeliveryItemResult.Failed(item, movError);
@@ -192,7 +216,7 @@ public sealed class DeliveryStage
foreach (var src in sources) foreach (var src in sources)
{ {
var name = Path.GetFileName(src); var name = destNames[src];
manifestFiles.Add(new manifestFiles.Add(new
{ {
shotCode = item.ShotCode, shotCode = item.ShotCode,
@@ -224,6 +248,108 @@ public sealed class DeliveryStage
} }
} }
/// <summary>
/// One shot of a MOV review package: place its preview MOV straight into
/// the (flat) review folder under the client-facing name.
///
/// A missing MOV is fatal here, unlike in an EXR delivery where the MOV is
/// a viewing copy beside the real deliverable — in a review it *is* the
/// deliverable, and a review folder quietly one shot short is worse than
/// one that says so.
/// </summary>
private DeliveryItemResult BuildReviewItem(
DeliveryManifestItem item, PathMapper mapper, bool alwaysCopy, bool alwaysHash, List<object> manifestFiles)
{
try
{
if (string.IsNullOrWhiteSpace(item.DeliveryMovPath))
{
return DeliveryItemResult.Failed(item, "No preview MOV is recorded for this version");
}
var movSrc = mapper.Map(item.DeliveryMovPath!);
if (!File.Exists(movSrc))
{
return DeliveryItemResult.Failed(item, $"Preview MOV not found: {movSrc}");
}
// ShotDir is the package folder itself for a review — the MOVs sit
// beside each other so a producer can scrub through them in order.
var reviewDir = mapper.Map(item.ShotDir);
Directory.CreateDirectory(reviewDir);
var name = string.IsNullOrWhiteSpace(item.DeliveredBaseName)
? Path.GetFileName(movSrc)
: item.DeliveredBaseName + Path.GetExtension(movSrc);
var dest = Path.Combine(reviewDir, name);
if (Place(movSrc, dest, alwaysCopy, out var copied) is string error)
{
return DeliveryItemResult.Failed(item, error);
}
var sourceLength = new FileInfo(movSrc).Length;
var destLength = new FileInfo(dest).Length;
// There is no validation-time digest for a MOV to check against, so
// a copy is proved against the source it came from: length always
// (it catches the truncation a full disk causes, for free), and the
// full hash when the config asks for it. A hard link is the source.
string? digest = null;
if (copied)
{
if (destLength != sourceLength)
{
return DeliveryItemResult.Failed(item,
$"Copied MOV is {destLength} bytes but the source is {sourceLength} — the copy is incomplete");
}
if (alwaysHash)
{
digest = XxHash64.HashFile(dest);
var sourceDigest = XxHash64.HashFile(movSrc);
if (!string.Equals(digest, sourceDigest, StringComparison.OrdinalIgnoreCase))
{
return DeliveryItemResult.Failed(item,
$"Copied MOV does not match its source: expected {sourceDigest}, got {digest}");
}
}
}
else if (alwaysHash)
{
digest = XxHash64.HashFile(dest);
}
manifestFiles.Add(new
{
shotCode = item.ShotCode,
relativePath = name,
bytes = destLength,
exportId = item.ExportId,
});
return new DeliveryItemResult
{
ItemId = item.ItemId,
ShotCode = item.ShotCode,
VersionString = item.VersionString,
Status = "VERIFIED",
// No EXR sequence is involved, so there is no shot folder to record.
ExrPath = null,
MovPath = dest,
FileCount = 1,
TotalBytes = destLength,
Checksum = digest,
LinkMode = copied ? "copy" : "hardlink",
FrameStart = item.FrameStart,
FrameEnd = item.FrameEnd,
};
}
catch (Exception ex)
{
return DeliveryItemResult.Failed(item, $"{ex.GetType().Name}: {ex.Message}");
}
}
/// <summary> /// <summary>
/// Hard-link when possible, copy when not. Returns null on success or the /// Hard-link when possible, copy when not. Returns null on success or the
/// error message. `copied` reports which happened, so the package records /// error message. `copied` reports which happened, so the package records
@@ -252,6 +378,31 @@ public sealed class DeliveryStage
} }
} }
/// <summary>
/// The delivered filename for one source frame: DeliveredBaseName with the
/// frame number (re-padded to the render's own convention) and extension —
/// never the internal render filename it was copied from. Falls back to
/// the source filename verbatim (never fatal) when there's no client-facing
/// base to use, or the frame number can't be parsed out of the source name.
/// </summary>
internal string DeliveredFrameName(string src, DeliveryManifestItem item, SequencePattern pattern)
{
var sourceName = Path.GetFileName(src);
if (string.IsNullOrWhiteSpace(item.DeliveredBaseName))
{
return sourceName;
}
var frame = pattern.FrameNumberOf(sourceName);
if (frame is null)
{
_log.LogWarning("Could not parse a frame number out of {Name} for {Shot} — delivering under its original name",
sourceName, item.ShotCode);
return sourceName;
}
var padding = Math.Max(1, pattern.Padding);
return $"{item.DeliveredBaseName}.{frame.Value.ToString().PadLeft(padding, '0')}{pattern.Extension}";
}
private static string SequenceChecksum(IEnumerable<string> files) private static string SequenceChecksum(IEnumerable<string> files)
{ {
var state = new XxHash64.State(0); var state = new XxHash64.State(0);
+36
View File
@@ -100,6 +100,12 @@ public sealed class BlenderManifest
public sealed class DeliveryManifest public sealed class DeliveryManifest
{ {
public string Stage { get; set; } = "DELIVERY"; public string Stage { get; set; } = "DELIVERY";
/// <summary>
/// "EXR_DELIVERY" builds the per-shot folders of EXRs + MOVs; "MOV_REVIEW"
/// builds a flat folder of preview MOVs for a formal review (§11.6). One
/// job type and one claim path either way — only what lands on disk differs.
/// </summary>
public string Kind { get; set; } = "EXR_DELIVERY";
public string PackageId { get; set; } = ""; public string PackageId { get; set; } = "";
public string PackageName { get; set; } = ""; public string PackageName { get; set; } = "";
public int PackageNumber { get; set; } public int PackageNumber { get; set; }
@@ -129,8 +135,22 @@ public sealed class DeliveryManifestItem
public string? Checksum { get; set; } public string? Checksum { get; set; }
public string? DeliveryMovPath { get; set; } public string? DeliveryMovPath { get; set; }
public string ShotDir { get; set; } = ""; public string ShotDir { get; set; } = "";
/// <summary>
/// Server-computed: "{clientCode}_{versionString}" when the shot has a
/// client naming code, else the studio's own "{shotCode}_cmp_TT_{versionString}".
/// The delivered EXR sequence and MOV are named from this, not the
/// internal render filename they're copied from.
/// </summary>
public string DeliveredBaseName { get; set; } = "";
/// <summary>When this export's validation ran — lets a linked package detect a source changed since QC.</summary> /// <summary>When this export's validation ran — lets a linked package detect a source changed since QC.</summary>
public DateTimeOffset? ValidatedAt { get; set; } public DateTimeOffset? ValidatedAt { get; set; }
/// <summary>
/// True on a MOV_REVIEW item: there is no EXR sequence, so SourceDir,
/// OutputPattern, FileCount and Checksum are empty and DeliveryMovPath is
/// the whole deliverable.
/// </summary>
public bool IsMovOnly => string.IsNullOrWhiteSpace(SourceDir);
} }
/// <summary>PREVIEW_ONLY manifest (server-built, RenderPipeline2 §9).</summary> /// <summary>PREVIEW_ONLY manifest (server-built, RenderPipeline2 §9).</summary>
@@ -155,6 +175,11 @@ public sealed class PreviewManifest
public string Mp4Output { get; set; } = ""; public string Mp4Output { get; set; } = "";
public string? SlateScopeProp { get; set; } public string? SlateScopeProp { get; set; }
public string? SlateSubmissionProp { get; set; } public string? SlateSubmissionProp { get; set; }
/// <summary>
/// Also encode the High quality MP4 from the MOV and upload the MOV itself
/// as the version's High Res file (server "preview.highQuality").
/// </summary>
public bool HighQuality { get; set; }
public SlateInfo Slate { get; set; } = new(); public SlateInfo Slate { get; set; } = new();
public int TotalFrames => FrameEnd - FrameStart + 1; public int TotalFrames => FrameEnd - FrameStart + 1;
@@ -186,6 +211,12 @@ public sealed class PreviewBuildResult
public int? FrameCount { get; set; } public int? FrameCount { get; set; }
public int? Width { get; set; } public int? Width { get; set; }
public int? Height { get; set; } public int? Height { get; set; }
/// <summary>
/// Seconds of slate ahead of picture in the preview comp (the SHOT layer's
/// in-point). Null on builds predating this field, or when the template has
/// no SHOT layer — the thumbnail then falls back to scanning from frame 0.
/// </summary>
public double? PictureStartSeconds { get; set; }
} }
/// <summary>The Render Manifest (§6.2) — the fields the render and validation stages need; the rest is preserved raw.</summary> /// <summary>The Render Manifest (§6.2) — the fields the render and validation stages need; the rest is preserved raw.</summary>
@@ -273,6 +304,11 @@ public sealed class PresignResponse
public string PresignedUrl { get; set; } = ""; public string PresignedUrl { get; set; } = "";
public string Key { get; set; } = ""; public string Key { get; set; } = "";
public string Url { get; set; } = ""; public string Url { get; set; } = "";
// Multipart (server ≥ 1.7.2 contract) — absent from older servers, which
// only ever return PresignedUrl.
public string? UploadId { get; set; }
public long PartSize { get; set; }
public List<string>? PartUrls { get; set; }
} }
public sealed class ExportDetailResponse public sealed class ExportDetailResponse
@@ -0,0 +1,143 @@
using System.Text.Json;
using Microsoft.Extensions.Logging;
namespace VFXReviewWorker;
/// <summary>
/// Uploads each preview's ProRes MOV (the version's High Res download) in the
/// background, after the job has already been finalized.
///
/// The MOV is by far the largest upload — hundreds of MB — and on a slow or
/// flaky uplink it held every preview job open for 10+ minutes, during which
/// the job looked stuck in the app and a worker restart threw the whole
/// preview away. Now the job completes as soon as the review MP4s are up, the
/// worker moves on to the next job, and the MOV follows; an "attach-highres"
/// report (through the ordered spooler, so always after its finalize) attaches
/// it to the version.
///
/// Pending uploads are files in highres-queue/, so a restart resumes them. The
/// MOV itself lives on the SAN beside the EXRs, never in scratch.
/// </summary>
public sealed class HighResUploader
{
private const int MaxAttempts = 5;
private readonly ApiClient _api;
private readonly ReportSpooler _spooler;
private readonly ILogger<HighResUploader> _log;
private readonly string _dir;
private readonly SemaphoreSlim _wake = new(0);
public HighResUploader(ApiClient api, ReportSpooler spooler, ILogger<HighResUploader> log)
{
_api = api;
_spooler = spooler;
_log = log;
_dir = Path.Combine(WorkerOptions.DataDir, "highres-queue");
Directory.CreateDirectory(_dir);
}
private sealed class Pending
{
public string JobId { get; set; } = "";
public string MachineId { get; set; } = "";
public string MovPath { get; set; } = "";
public int Attempts { get; set; }
}
public void Enqueue(string jobId, string machineId, string movPath)
{
var item = new Pending { JobId = jobId, MachineId = machineId, MovPath = movPath };
var name = $"{DateTimeOffset.UtcNow.UtcTicks:D20}_{jobId}.json";
var tmp = Path.Combine(_dir, name + ".tmp");
File.WriteAllText(tmp, JsonSerializer.Serialize(item, WorkerOptions.JsonOpts));
File.Move(tmp, Path.Combine(_dir, name));
_log.LogInformation("ProRes for job {JobId} queued for background upload ({MB:F0} MB)",
jobId, File.Exists(movPath) ? new FileInfo(movPath).Length / 1048576.0 : 0);
_wake.Release();
}
/// <summary>Long-running loop; started once by the worker service.</summary>
public async Task RunAsync(CancellationToken ct)
{
var backoff = TimeSpan.FromSeconds(30);
while (!ct.IsCancellationRequested)
{
var next = Directory.EnumerateFiles(_dir, "*.json").OrderBy(f => f, StringComparer.Ordinal).FirstOrDefault();
if (next is null)
{
try { await _wake.WaitAsync(TimeSpan.FromSeconds(30), ct); } catch (OperationCanceledException) { break; }
continue;
}
Pending? item;
try { item = JsonSerializer.Deserialize<Pending>(File.ReadAllText(next), WorkerOptions.JsonOpts); }
catch { item = null; }
if (item is null || string.IsNullOrEmpty(item.JobId))
{
_log.LogWarning("Discarding unreadable ProRes queue file {File}", next);
TryDelete(next);
continue;
}
if (!File.Exists(item.MovPath))
{
_log.LogWarning("ProRes for job {JobId} is gone ({Path}) — not uploading", item.JobId, item.MovPath);
Report(item, null, $"MOV not found at {item.MovPath}");
TryDelete(next);
continue;
}
string? key;
try
{
key = await _api.UploadArtifactAsync(item.JobId, item.MachineId, "highres", item.MovPath, "video/quicktime", ct);
}
catch (OperationCanceledException) when (ct.IsCancellationRequested)
{
_log.LogInformation("Worker stopping — ProRes upload for job {JobId} resumes on next start", item.JobId);
break;
}
if (key is not null)
{
Report(item, key, null);
TryDelete(next);
backoff = TimeSpan.FromSeconds(30);
continue;
}
item.Attempts++;
if (item.Attempts >= MaxAttempts)
{
_log.LogWarning("ProRes upload for job {JobId} failed {N} times — giving up", item.JobId, item.Attempts);
Report(item, null, $"upload failed {item.Attempts} times (see the worker log)");
TryDelete(next);
continue;
}
_log.LogWarning("ProRes upload for job {JobId} failed (attempt {N}/{Max}); retrying in {Sec}s",
item.JobId, item.Attempts, MaxAttempts, backoff.TotalSeconds);
try { File.WriteAllText(next, JsonSerializer.Serialize(item, WorkerOptions.JsonOpts)); } catch { /* retried anyway */ }
try { await Task.Delay(backoff, ct); } catch (OperationCanceledException) { break; }
backoff = TimeSpan.FromSeconds(Math.Min(backoff.TotalSeconds * 2, 600));
}
}
private void Report(Pending item, string? key, string? error)
{
_spooler.Enqueue("attach-highres", item.JobId, new Dictionary<string, object?>
{
["machineId"] = item.MachineId,
["highResKey"] = key,
["highResFileName"] = key is null ? null : Path.GetFileName(item.MovPath),
["highResSize"] = key is null ? null : new FileInfo(item.MovPath).Length,
["error"] = error,
});
}
private static void TryDelete(string path)
{
try { File.Delete(path); } catch { /* next pass */ }
}
}
+59 -6
View File
@@ -18,11 +18,14 @@ public sealed class JobExecutor
private readonly DeliveryStage _delivery; private readonly DeliveryStage _delivery;
private readonly BlenderRunner _blender; private readonly BlenderRunner _blender;
private readonly ReportSpooler _spooler; private readonly ReportSpooler _spooler;
private readonly HighResUploader _highRes;
private readonly ILogger<JobExecutor> _log; private readonly ILogger<JobExecutor> _log;
public JobExecutor(WorkerOptions options, ApiClient api, AerenderRunner runner, PreviewStage preview, public JobExecutor(WorkerOptions options, ApiClient api, AerenderRunner runner, PreviewStage preview,
ValidationStage validation, DeliveryStage delivery, BlenderRunner blender, ReportSpooler spooler, ILogger<JobExecutor> log) ValidationStage validation, DeliveryStage delivery, BlenderRunner blender, ReportSpooler spooler,
HighResUploader highRes, ILogger<JobExecutor> log)
{ {
_highRes = highRes;
_options = options; _options = options;
_api = api; _api = api;
_runner = runner; _runner = runner;
@@ -76,12 +79,15 @@ public sealed class JobExecutor
{ {
long totalBytes = 0; long totalBytes = 0;
int fileCount = 0; int fileCount = 0;
var prefix = AerenderRunner.OutputPatternPrefix(manifest.OutputPattern); // Prefix and extension both: the preview MOV/MP4 for this
// version share the basename and live in this same folder, and
// counting them as frames would inflate the EXR stats.
var pattern = SequencePattern.FromOutputPattern(manifest.OutputPattern);
try try
{ {
foreach (var f in Directory.EnumerateFiles(outputDirLocal)) foreach (var f in Directory.EnumerateFiles(outputDirLocal))
{ {
if (!Path.GetFileName(f).StartsWith(prefix, StringComparison.OrdinalIgnoreCase)) continue; if (!pattern.MatchesOutputFile(Path.GetFileName(f))) continue;
fileCount++; fileCount++;
totalBytes += new FileInfo(f).Length; totalBytes += new FileInfo(f).Length;
} }
@@ -94,8 +100,8 @@ public sealed class JobExecutor
// range, template mismatch, silently swallowed error). // range, template mismatch, silently swallowed error).
// Until Phase 3 validation exists, an empty output dir must // Until Phase 3 validation exists, an empty output dir must
// never become READY_FOR_QC. // never become READY_FOR_QC.
_log.LogError("Job {JobId}: aerender exited 0 but no \"{Prefix}*\" files exist in {Dir} — reporting failure", _log.LogError("Job {JobId}: aerender exited 0 but no \"{Prefix}*{Ext}\" files exist in {Dir} — reporting failure",
job.Id, prefix, outputDirLocal); job.Id, pattern.Prefix, pattern.Extension, outputDirLocal);
_spooler.Enqueue("fail", job.Id, new Dictionary<string, object?> _spooler.Enqueue("fail", job.Id, new Dictionary<string, object?>
{ {
["machineId"] = machineId, ["machineId"] = machineId,
@@ -415,8 +421,15 @@ public sealed class JobExecutor
return; // temp AEP is deliberately kept for debugging return; // temp AEP is deliberately kept for debugging
} }
// From here on aerender is done and the app would keep showing its
// last frame line; this reports what the worker is doing instead,
// and renews the lease through the encode and uploads.
await using var status = new LeaseKeepAlive(_api, job.Id, machineId, TimeSpan.FromSeconds(10), shutdown);
status.Line($"Preview rendered in {result.Seconds:F0}s — uploading review media");
var previewKey = await _api.UploadArtifactAsync( var previewKey = await _api.UploadArtifactAsync(
job.Id, machineId, "preview", result.Mp4Path!, "video/mp4", shutdown); job.Id, machineId, "preview", result.Mp4Path!, "video/mp4", shutdown,
status.Track("preview MP4", result.Mp4Path!));
if (previewKey is null) if (previewKey is null)
{ {
// The renders are on the SAN and fine — only the upload failed, // The renders are on the SAN and fine — only the upload failed,
@@ -430,6 +443,7 @@ public sealed class JobExecutor
}); });
return; return;
} }
status.Line("Preview MP4 uploaded");
string? thumbKey = null; string? thumbKey = null;
if (result.ThumbnailPath is not null) if (result.ThumbnailPath is not null)
@@ -438,6 +452,30 @@ public sealed class JobExecutor
job.Id, machineId, "thumbnail", result.ThumbnailPath, "image/jpeg", shutdown); job.Id, machineId, "thumbnail", result.ThumbnailPath, "image/jpeg", shutdown);
} }
// High quality MP4 + the MOV as the version's High Res download
// (§9.6). Both optional: a failure here costs the extras, never the
// preview, which is already safely uploaded. The MOV is uploaded in
// the background after finalize (HighResUploader) — it is the big
// one and used to hold the job open for many minutes.
string? hqKey = null;
var highResPending = false;
if (manifest.HighQuality)
{
status.Line("Encoding High quality MP4");
var hqPath = await _preview.TryMakeHighQualityAsync(job.Id, result.MovPath!, result.Mp4Path!, shutdown);
if (hqPath is not null)
{
hqKey = await _api.UploadArtifactAsync(job.Id, machineId, "preview", hqPath, "video/mp4", shutdown,
status.Track("High quality MP4", hqPath));
if (hqKey is null) _log.LogWarning("High quality MP4 upload failed for job {JobId}", job.Id);
status.Line(hqKey is null ? "High quality MP4 upload FAILED (see worker log)" : "High quality MP4 uploaded");
}
highResPending = result.MovPath is not null && File.Exists(result.MovPath);
if (highResPending)
status.Line("ProRes MOV queued for background upload — completing the job now");
}
_spooler.Enqueue("finalize", job.Id, new Dictionary<string, object?> _spooler.Enqueue("finalize", job.Id, new Dictionary<string, object?>
{ {
["machineId"] = machineId, ["machineId"] = machineId,
@@ -446,6 +484,8 @@ public sealed class JobExecutor
["deliveryMovPath"] = manifest.MovOutput, ["deliveryMovPath"] = manifest.MovOutput,
["previewMovKey"] = previewKey, ["previewMovKey"] = previewKey,
["thumbnailKey"] = thumbKey, ["thumbnailKey"] = thumbKey,
["hqPreviewKey"] = hqKey,
["highResPending"] = highResPending,
}, },
["renderStats"] = new Dictionary<string, object?> ["renderStats"] = new Dictionary<string, object?>
{ {
@@ -458,9 +498,16 @@ public sealed class JobExecutor
["frameCount"] = result.Build?.FrameCount, ["frameCount"] = result.Build?.FrameCount,
["fps"] = manifest.Fps, ["fps"] = manifest.Fps,
["fileName"] = Path.GetFileName(result.Mp4Path!), ["fileName"] = Path.GetFileName(result.Mp4Path!),
// Slate length, so the review player can place the handle
// markers exactly instead of inferring it (server ≥ 2026-09-22).
["pictureStartSeconds"] = result.Build?.PictureStartSeconds,
}, },
}); });
// Enqueued after finalize: its attach report must reach the spooler
// behind finalize, which creates the version it attaches to.
if (highResPending) _highRes.Enqueue(job.Id, machineId, result.MovPath!);
// Only clean up once the outputs are safely reported. // Only clean up once the outputs are safely reported.
CleanScratch(job.Id, result.TempAep); CleanScratch(job.Id, result.TempAep);
} }
@@ -488,6 +535,12 @@ public sealed class JobExecutor
PreviewStage.TryDelete(Path.Combine(WorkerOptions.ScratchDir, $"job_{jobId}_run.jsx")); PreviewStage.TryDelete(Path.Combine(WorkerOptions.ScratchDir, $"job_{jobId}_run.jsx"));
PreviewStage.TryDelete(Path.Combine(WorkerOptions.ScratchDir, $"job_{jobId}_thumb.jpg")); PreviewStage.TryDelete(Path.Combine(WorkerOptions.ScratchDir, $"job_{jobId}_thumb.jpg"));
if (tempAep is not null) PreviewStage.TryDelete(tempAep); if (tempAep is not null) PreviewStage.TryDelete(tempAep);
try
{
var hqDir = PreviewStage.HighQualityDir(jobId);
if (Directory.Exists(hqDir)) Directory.Delete(hqDir, recursive: true);
}
catch { /* scratch only */ }
} }
/// <summary> /// <summary>
@@ -0,0 +1,103 @@
using System.Diagnostics;
using System.Text;
namespace VFXReviewWorker;
/// <summary>
/// Renews a job's lease with progress reports while the worker does something
/// long that reports nothing on its own — the High quality encode and the
/// uploads can each outlast a 300 s lease, and an expired lease lets the
/// reaper hand the job to another machine mid-upload.
///
/// Each report also replaces the job's log tail with what the worker is doing
/// now ("Uploading High quality MP4: 12.0 / 34.0 MB…"). Without it the app
/// keeps showing aerender's last frame line and a busy job looks hung.
/// </summary>
internal sealed class LeaseKeepAlive : IAsyncDisposable
{
private readonly ApiClient _api;
private readonly string _jobId;
private readonly string _machineId;
private readonly CancellationTokenSource _cts;
private readonly SemaphoreSlim _wake = new(0);
private readonly Task _loop;
private readonly object _lock = new();
private readonly List<string> _lines = new();
private string? _current;
public LeaseKeepAlive(ApiClient api, string jobId, string machineId, TimeSpan interval, CancellationToken shutdown)
{
_api = api;
_jobId = jobId;
_machineId = machineId;
_cts = CancellationTokenSource.CreateLinkedTokenSource(shutdown);
var token = _cts.Token;
_loop = Task.Run(async () =>
{
try
{
while (!token.IsCancellationRequested)
{
// Best-effort by contract (ApiClient.ProgressAsync never throws
// on transport errors); progress stays at 1.0 — the render is done.
await _api.ProgressAsync(_jobId, _machineId, 1.0, null, null, null, Render(), token);
await _wake.WaitAsync(interval, token);
}
}
catch (OperationCanceledException)
{
// stopped
}
});
}
/// <summary>Adds a finished step to the status shown in the app.</summary>
public void Line(string text)
{
lock (_lock)
{
_current = null;
_lines.Add($"{DateTime.Now:HH:mm:ss} {text}");
}
_wake.Release();
}
/// <summary>
/// Progress callback for <see cref="ApiClient.UploadArtifactAsync"/>: keeps
/// one live line ("Uploading X: 12.0 / 34.0 MB (35%, 2.1 MB/s)") up to date.
/// </summary>
public Action<long> Track(string label, string filePath)
{
long total = File.Exists(filePath) ? new FileInfo(filePath).Length : 0;
var sw = Stopwatch.StartNew();
lock (_lock) _current = $"Uploading {label}: 0.0 / {Mb(total)} MB";
_wake.Release();
return sent =>
{
var pct = total > 0 ? 100.0 * sent / total : 0;
var speed = sent / 1048576.0 / Math.Max(0.001, sw.Elapsed.TotalSeconds);
lock (_lock) _current = $"Uploading {label}: {Mb(sent)} / {Mb(total)} MB ({pct:F0}%, {speed:F1} MB/s)";
};
}
private static string Mb(long bytes) => (bytes / 1048576.0).ToString("F1");
private string Render()
{
lock (_lock)
{
var sb = new StringBuilder();
foreach (var l in _lines) sb.AppendLine(l);
if (_current is not null) sb.AppendLine($"{DateTime.Now:HH:mm:ss} {_current}");
return sb.ToString();
}
}
public async ValueTask DisposeAsync()
{
_cts.Cancel();
try { await _loop; } catch { /* already reported */ }
_cts.Dispose();
_wake.Dispose();
}
}
+268 -10
View File
@@ -179,7 +179,7 @@ public sealed class PreviewStage
null, null, null, build.TempAep, build, sw.Elapsed.TotalSeconds); null, null, null, build.TempAep, build, sw.Elapsed.TotalSeconds);
} }
var thumbnail = await TryMakeThumbnailAsync(job.Id, mp4Local, shutdown); var thumbnail = await TryMakeThumbnailAsync(job.Id, mp4Local, build, manifest.Fps, shutdown);
sw.Stop(); sw.Stop();
_log.LogInformation("Preview complete for job {JobId} in {Sec:F0}s (mov + mp4{Thumb})", _log.LogInformation("Preview complete for job {JobId} in {Sec:F0}s (mov + mp4{Thumb})",
@@ -231,14 +231,197 @@ public sealed class PreviewStage
return process.ExitCode; return process.ExitCode;
} }
/// <summary>Optional 960-wide poster frame at 25% duration (§9.1). Never fatal.</summary> /// <summary>
private async Task<string?> TryMakeThumbnailAsync(string jobId, string mp4Path, CancellationToken ct) /// Optional 960-wide poster frame at 25% of <em>picture</em> duration
/// (§9.1). Never fatal.
/// </summary>
/// <remarks>
/// The preview MP4 opens on the Netflix slate, so the frame has to be taken
/// relative to picture rather than to the file. This previously used
/// ffmpeg's <c>thumbnail</c> filter, which considers only the first 100
/// frames — on a slated preview that is the slate card, which is what every
/// thumbnail in the system was until now. Seeking to
/// <c>pictureStart + 25%</c> matches what §9.1 always documented and is what
/// makes these frames usable as shot thumbnails.
///
/// A build that reports no picture start (older worker, or a template with
/// no SHOT layer) keeps the old whole-file behaviour rather than guessing.
/// </remarks>
private async Task<string?> TryMakeThumbnailAsync(
string jobId, string mp4Path, PreviewBuildResult? build, double fps, CancellationToken ct)
{
if (string.IsNullOrWhiteSpace(_options.FfmpegPath))
{
_log.LogWarning(
"No thumbnail for job {JobId}: ffmpegPath is not set in config.json. " +
"Thumbnails are skipped, and shots cannot take a frame from this render.",
jobId);
return null;
}
if (!File.Exists(_options.FfmpegPath))
{
_log.LogWarning(
"No thumbnail for job {JobId}: ffmpegPath points at {Path}, which does not exist.",
jobId, _options.FfmpegPath);
return null;
}
var outPath = Path.Combine(WorkerOptions.ScratchDir, $"job_{jobId}_thumb.jpg");
var seek = ThumbnailSeekSeconds(build, fps);
if (seek is { } t)
{
_log.LogInformation(
"Thumbnail for job {JobId}: seeking to {Seek:F2}s (slate {Start:F2}s + 25% of {Frames} frames @ {Fps}fps)",
jobId, t, build!.PictureStartSeconds, build.FrameCount, fps);
var attempt = await RunFfmpegThumbnailAsync(jobId, mp4Path, outPath, t, ct);
if (attempt == ThumbAttempt.Wrote) return outPath;
// A hung or unstartable ffmpeg will hang the same way a second
// time, and each attempt costs the full two-minute cap.
if (attempt == ThumbAttempt.Broken) return null;
// The seek is derived from what the AE build reported; if those
// numbers disagree with the rendered file, ffmpeg lands past the
// end and writes nothing. Falling back to the whole-file scan means
// a wrong seek costs picture content, never the thumbnail itself.
_log.LogWarning(
"Thumbnail seek to {Seek:F2}s produced nothing for job {JobId} — retrying across the whole file. " +
"The frame will likely be the slate.", t, jobId);
}
else
{
_log.LogInformation(
"Thumbnail for job {JobId}: build reported no picture start, scanning the whole file " +
"(the frame will likely be the slate).", jobId);
}
if (await RunFfmpegThumbnailAsync(jobId, mp4Path, outPath, null, ct) == ThumbAttempt.Wrote) return outPath;
_log.LogWarning("No thumbnail produced for job {JobId} — see the ffmpeg output above.", jobId);
return null;
}
/// <summary>Scratch folder for a job's High quality encode.</summary>
internal static string HighQualityDir(string jobId) =>
Path.Combine(WorkerOptions.ScratchDir, $"job_{jobId}_hq");
/// <summary>
/// High quality review MP4 (§9.6): the delivery MOV re-encoded as
/// full-resolution, high-bitrate H.264 High — the player's "High" quality.
/// ProRes itself only plays in Safari on a Mac, so the MOV is offered as a
/// download and this is what streams. Never fatal: without it the version
/// simply has Standard quality only.
/// </summary>
public async Task<string?> TryMakeHighQualityAsync(
string jobId, string movPath, string mp4Path, CancellationToken ct)
{ {
if (string.IsNullOrWhiteSpace(_options.FfmpegPath) || !File.Exists(_options.FfmpegPath)) if (string.IsNullOrWhiteSpace(_options.FfmpegPath) || !File.Exists(_options.FfmpegPath))
{ {
_log.LogWarning("No High quality MP4 for job {JobId}: ffmpegPath is not set or missing.", jobId);
return null; return null;
} }
var outPath = Path.Combine(WorkerOptions.ScratchDir, $"job_{jobId}_thumb.jpg"); if (!File.Exists(movPath))
{
_log.LogWarning("No High quality MP4 for job {JobId}: MOV not found at {Path}.", jobId, movPath);
return null;
}
var dir = HighQualityDir(jobId);
Directory.CreateDirectory(dir);
// Named after the review MP4 so the stored object reads as its sibling.
var outPath = Path.Combine(dir, Path.GetFileNameWithoutExtension(mp4Path) + "_HQ.mp4");
TryDelete(outPath);
var args = new List<string>
{
"-y", "-i", movPath,
"-map", "0:v:0", "-map", "0:a?",
// Visually lossless for review, capped so a busy shot can't balloon
// past what a good connection streams. yuv420p 8-bit High profile
// is the combination every browser decodes.
"-c:v", "libx264", "-profile:v", "high", "-preset", "medium", "-crf", "14",
"-maxrate", "100M", "-bufsize", "200M", "-pix_fmt", "yuv420p",
"-c:a", "aac", "-b:a", "256k",
// Index at the front so the player can start before it's all loaded
"-movflags", "+faststart",
outPath,
};
var psi = new ProcessStartInfo
{
FileName = _options.FfmpegPath,
RedirectStandardOutput = true,
RedirectStandardError = true,
UseShellExecute = false,
CreateNoWindow = true,
};
foreach (var a in args) psi.ArgumentList.Add(a);
var sw = Stopwatch.StartNew();
try
{
using var process = Process.Start(psi);
if (process is null)
{
_log.LogWarning("Could not start ffmpeg for the High quality MP4 (job {JobId})", jobId);
return null;
}
// Drain both pipes (see RunFfmpegThumbnailAsync — an unread pipe deadlocks ffmpeg).
var stderrTask = process.StandardError.ReadToEndAsync();
var stdoutTask = process.StandardOutput.ReadToEndAsync();
using var timeout = CancellationTokenSource.CreateLinkedTokenSource(ct);
timeout.CancelAfter(TimeSpan.FromMinutes(30));
try
{
await process.WaitForExitAsync(timeout.Token);
}
catch (OperationCanceledException)
{
_log.LogWarning("High quality encode for job {JobId} timed out or was cancelled — killing ffmpeg", jobId);
try { process.Kill(entireProcessTree: true); } catch { }
TryDelete(outPath);
return null;
}
var stderr = await stderrTask;
await stdoutTask;
if (process.ExitCode == 0 && File.Exists(outPath) && new FileInfo(outPath).Length > 0)
{
_log.LogInformation("High quality MP4 for job {JobId} encoded in {Sec:F0}s ({MB:F0} MB)",
jobId, sw.Elapsed.TotalSeconds, new FileInfo(outPath).Length / 1e6);
return outPath;
}
_log.LogWarning("High quality encode failed for job {JobId} (exit {Exit}): {Stderr}",
jobId, process.ExitCode, Tail(stderr, 1200));
TryDelete(outPath);
return null;
}
catch (Exception ex)
{
_log.LogWarning(ex, "High quality encode failed for job {JobId} (non-fatal)", jobId);
return null;
}
}
/// <summary>How one ffmpeg attempt ended.</summary>
private enum ThumbAttempt
{
/// <summary>A thumbnail was written.</summary>
Wrote,
/// <summary>ffmpeg ran and wrote nothing — a different attempt may work.</summary>
NoOutput,
/// <summary>ffmpeg hung or could not start — retrying costs minutes and fixes nothing.</summary>
Broken,
}
/// <summary>
/// One ffmpeg invocation. <paramref name="seekSeconds"/> null means the old
/// whole-file <c>thumbnail</c> filter. Logs ffmpeg's own diagnosis when no
/// file is produced.
/// </summary>
private async Task<ThumbAttempt> RunFfmpegThumbnailAsync(
string jobId, string mp4Path, string outPath, double? seekSeconds, CancellationToken ct)
{
TryDelete(outPath); TryDelete(outPath);
var psi = new ProcessStartInfo var psi = new ProcessStartInfo
@@ -249,27 +432,102 @@ public sealed class PreviewStage
UseShellExecute = false, UseShellExecute = false,
CreateNoWindow = true, CreateNoWindow = true,
}; };
foreach (var a in new[] { "-y", "-i", mp4Path, "-vf", "thumbnail,scale=960:-1", "-frames:v", "1", outPath })
var args = new List<string> { "-y" };
if (seekSeconds is { } t)
{ {
psi.ArgumentList.Add(a); // Before -i: ffmpeg seeks by keyframe, which is fast and accurate
// enough for a poster frame.
args.Add("-ss");
args.Add(t.ToString("0.###", System.Globalization.CultureInfo.InvariantCulture));
args.Add("-i");
args.Add(mp4Path);
args.Add("-vf");
args.Add("scale=960:-1");
} }
else
{
args.Add("-i");
args.Add(mp4Path);
args.Add("-vf");
args.Add("thumbnail,scale=960:-1");
}
args.Add("-frames:v");
args.Add("1");
args.Add(outPath);
foreach (var a in args) psi.ArgumentList.Add(a);
try try
{ {
using var process = Process.Start(psi); using var process = Process.Start(psi);
if (process is null) return null; if (process is null)
{
_log.LogWarning("Could not start ffmpeg at {Path} for job {JobId}", _options.FfmpegPath, jobId);
return ThumbAttempt.Broken;
}
// Drain BOTH pipes while the process runs. Windows gives an
// anonymous pipe a ~4 KB buffer; ffmpeg's banner and stream summary
// exceed that on their own, so a redirected-but-unread pipe fills,
// ffmpeg blocks forever on the write, and the wait below times out
// with the process still alive. That is a deadlock, not a slow
// encode, and it is why this step failed with nothing but a
// cancellation to show for it.
var stderrTask = process.StandardError.ReadToEndAsync();
var stdoutTask = process.StandardOutput.ReadToEndAsync();
using var timeout = CancellationTokenSource.CreateLinkedTokenSource(ct); using var timeout = CancellationTokenSource.CreateLinkedTokenSource(ct);
timeout.CancelAfter(TimeSpan.FromMinutes(2)); timeout.CancelAfter(TimeSpan.FromMinutes(2));
try
{
await process.WaitForExitAsync(timeout.Token); await process.WaitForExitAsync(timeout.Token);
return File.Exists(outPath) ? outPath : null; }
catch (OperationCanceledException) when (!ct.IsCancellationRequested)
{
// Our own 2-minute cap, not a shutdown: leaving ffmpeg running
// would hold the scratch file open and leak a process per job.
_log.LogWarning(
"ffmpeg timed out after 2 minutes for job {JobId} — killing it. Command: {Args}",
jobId, string.Join(" ", args));
try { process.Kill(entireProcessTree: true); } catch { }
return ThumbAttempt.Broken;
}
var stderr = await stderrTask;
await stdoutTask;
if (File.Exists(outPath) && new FileInfo(outPath).Length > 0) return ThumbAttempt.Wrote;
_log.LogWarning(
"ffmpeg wrote no thumbnail for job {JobId} (exit {Exit}). Command: {Args} -- ffmpeg said: {Stderr}",
jobId, process.ExitCode, string.Join(" ", args), Tail(stderr, 1200));
return ThumbAttempt.NoOutput;
} }
catch (Exception ex) catch (Exception ex)
{ {
_log.LogWarning(ex, "Thumbnail generation failed (non-fatal)"); _log.LogWarning(ex, "Thumbnail generation failed for job {JobId} (non-fatal)", jobId);
return null; return ThumbAttempt.Broken;
} }
} }
/// <summary>Last <paramref name="max"/> characters — ffmpeg puts the error at the end.</summary>
private static string Tail(string? text, int max) =>
string.IsNullOrEmpty(text) ? "(no output)"
: text.Length <= max ? text
: text[^max..];
/// <summary>
/// Timestamp for the poster frame: a quarter of the way into picture,
/// skipping the slate. Null when the build did not report where picture
/// starts, or when the numbers do not describe a real clip.
/// </summary>
internal static double? ThumbnailSeekSeconds(PreviewBuildResult? build, double fps)
{
if (build?.PictureStartSeconds is not { } start || start < 0) return null;
if (build.FrameCount is not { } frames || frames <= 0) return null;
if (fps <= 0) return null;
return start + (frames / fps) * 0.25;
}
private static PreviewStageResult Fail(string message, bool retryable, Stopwatch sw, PreviewBuildResult? build = null) private static PreviewStageResult Fail(string message, bool retryable, Stopwatch sw, PreviewBuildResult? build = null)
{ {
sw.Stop(); sw.Stop();
+1
View File
@@ -37,6 +37,7 @@ builder.Logging.AddProvider(new FileLoggerProvider());
builder.Services.AddSingleton(options); builder.Services.AddSingleton(options);
builder.Services.AddSingleton<ApiClient>(); builder.Services.AddSingleton<ApiClient>();
builder.Services.AddSingleton<ReportSpooler>(); builder.Services.AddSingleton<ReportSpooler>();
builder.Services.AddSingleton<HighResUploader>();
builder.Services.AddSingleton<AerenderRunner>(); builder.Services.AddSingleton<AerenderRunner>();
builder.Services.AddSingleton<PreviewStage>(); builder.Services.AddSingleton<PreviewStage>();
builder.Services.AddSingleton<ValidationStage>(); builder.Services.AddSingleton<ValidationStage>();
@@ -0,0 +1,42 @@
using System.Net;
namespace VFXReviewWorker;
/// <summary>
/// StreamContent that reports bytes sent, so a long upload can show progress.
/// Length is computed from the stream, so the PUT still carries Content-Length
/// (presigned S3 uploads reject chunked bodies).
/// </summary>
internal sealed class ProgressStreamContent : HttpContent
{
private readonly Stream _source;
private readonly Action<long>? _onProgress;
public ProgressStreamContent(Stream source, Action<long>? onProgress)
{
_source = source;
_onProgress = onProgress;
}
protected override Task SerializeToStreamAsync(Stream stream, TransportContext? context) =>
SerializeToStreamAsync(stream, context, CancellationToken.None);
protected override async Task SerializeToStreamAsync(Stream stream, TransportContext? context, CancellationToken ct)
{
var buffer = new byte[81920];
long sent = 0;
int read;
while ((read = await _source.ReadAsync(buffer, ct)) > 0)
{
await stream.WriteAsync(buffer.AsMemory(0, read), ct);
sent += read;
_onProgress?.Invoke(sent);
}
}
protected override bool TryComputeLength(out long length)
{
length = _source.Length;
return true;
}
}
@@ -15,7 +15,7 @@
every change that gets published. publish.ps1 appends the git SHA via every change that gets published. publish.ps1 appends the git SHA via
SourceRevisionId, giving "1.1.0+feb1c7b". SourceRevisionId, giving "1.1.0+feb1c7b".
--> -->
<Version>1.5.1</Version> <Version>1.7.2</Version>
</PropertyGroup> </PropertyGroup>
<ItemGroup> <ItemGroup>
+109 -17
View File
@@ -350,6 +350,31 @@ public sealed class ValidationStage
return; return;
} }
var deltaOf = (TimecodeReference r) =>
renderTc.ToFrames(fps) - (r.PlateTimecode.ToFrames(fps) + (renderFirstFrame - r.PlateFirstFrame));
// A shot with several delivered elements: the panel names the longest
// as the timing plate, but the comp may have been anchored to another
// (BG01 and FG01 carry unrelated camera timecodes). When the timing
// plate disagrees, the manifest's other delivered plates are tried
// before failing. The comparison is unchanged — it is still a plate, so
// a match is a real PASS and no match still FAILs against the timing plate.
var timingPlate = reference;
var alternatesTried = new List<object>();
if (reference.Kind == "manifest" && deltaOf(reference) != 0)
{
foreach (var alternate in ResolveAlternatePlates(m, renderFirstFrame, reference))
{
var altDelta = deltaOf(alternate);
alternatesTried.Add(new { platePath = alternate.PlatePath, plateTimecode = alternate.PlateTimecode.ToString(), deltaFrames = altDelta });
if (altDelta == 0)
{
reference = alternate;
break;
}
}
}
// plate_fps — the render's rate against the plate's own. // plate_fps — the render's rate against the plate's own.
// //
// timecode_fps only compares the render to the manifest, and both come // timecode_fps only compares the render to the manifest, and both come
@@ -377,8 +402,8 @@ public sealed class ValidationStage
var expectedFrames = reference.PlateTimecode.ToFrames(fps) + (renderFirstFrame - reference.PlateFirstFrame); var expectedFrames = reference.PlateTimecode.ToFrames(fps) + (renderFirstFrame - reference.PlateFirstFrame);
var expected = Timecode.FromFrames(expectedFrames, fps); var expected = Timecode.FromFrames(expectedFrames, fps);
var actualFrames = renderTc.ToFrames(fps); var deltaFrames = deltaOf(reference);
var deltaFrames = actualFrames - expectedFrames; var matchedAlternate = !ReferenceEquals(reference, timingPlate);
var details = new var details = new
{ {
reference = reference.Kind, reference = reference.Kind,
@@ -387,10 +412,14 @@ public sealed class ValidationStage
plateFirstFrame = reference.PlateFirstFrame, plateFirstFrame = reference.PlateFirstFrame,
renderFirstFrame, renderFirstFrame,
deltaFrames, deltaFrames,
timingPlatePath = timingPlate.PlatePath,
matchedAlternate,
alternatesTried,
}; };
if (deltaFrames == 0) if (deltaFrames == 0)
{ {
var timingDelta = deltaOf(timingPlate);
// The API fallback proves nothing on its own (§8.1a): it is the // The API fallback proves nothing on its own (§8.1a): it is the
// editorial in-point minus a handle count that may not be this // editorial in-point minus a handle count that may not be this
// plate's, so a match is reported as a WARN, never a PASS. // plate's, so a match is reported as a WARN, never a PASS.
@@ -398,7 +427,11 @@ public sealed class ValidationStage
? ValidationCheck.Warn("timecode_plate_match", expected.ToString(), renderTc.ToString(), ? ValidationCheck.Warn("timecode_plate_match", expected.ToString(), renderTc.ToString(),
"Matches the API timecode less handles, but the plate itself could not be read — unverified.", details) "Matches the API timecode less handles, but the plate itself could not be read — unverified.", details)
: ValidationCheck.Pass("timecode_plate_match", expected.ToString(), renderTc.ToString(), : ValidationCheck.Pass("timecode_plate_match", expected.ToString(), renderTc.ToString(),
$"Matches {reference.Kind} plate {Path.GetFileName(reference.PlatePath ?? "")}", details)); $"Matches {reference.Kind} plate {Path.GetFileName(reference.PlatePath ?? "")}" +
(matchedAlternate
? $" (the timing plate {Path.GetFileName(timingPlate.PlatePath ?? "")} is {(timingDelta > 0 ? "+" : "")}{timingDelta} frames off — the comp was anchored to this element instead)"
: ""),
details));
return; return;
} }
@@ -409,6 +442,9 @@ public sealed class ValidationStage
? $"That is exactly the {reference.HandleFrames}-frame handle: the comp was anchored to the editorial in-point instead of the plate's first frame." ? $"That is exactly the {reference.HandleFrames}-frame handle: the comp was anchored to the editorial in-point instead of the plate's first frame."
: renderTc.Hours == 0 && renderTc.Minutes == 0 : renderTc.Hours == 0 && renderTc.Minutes == 0
? "A near-zero timecode means the comp had no source timecode at all and AE derived it from the frame number." ? "A near-zero timecode means the comp had no source timecode at all and AE derived it from the frame number."
: "") +
(alternatesTried.Count > 0
? $" Also checked {alternatesTried.Count} other delivered plate{(alternatesTried.Count == 1 ? "" : "s")} in the manifest: none match."
: ""); : "");
checks.Add(reference.Kind == "api" checks.Add(reference.Kind == "api"
@@ -430,20 +466,9 @@ public sealed class ValidationStage
var timing = m.Source?.TimingPlate; var timing = m.Source?.TimingPlate;
if (timing is not null && !string.IsNullOrWhiteSpace(timing.Path)) if (timing is not null && !string.IsNullOrWhiteSpace(timing.Path))
{ {
var local = mapper.Map(timing.Path); var manifestPlate = ReadManifestPlate(timing, mapper, handleFrames, renderFirstFrame);
var header = File.Exists(local) ? ExrHeader.TryRead(local) : null; if (manifestPlate is not null) return manifestPlate;
if (header?.Timecode is not null) _log.LogWarning("Timing plate from manifest is unreadable: {Path}", mapper.Map(timing.Path));
{
// The plate's own file numbering, never the comp's frame range:
// the render's first frame is in output numbering, so anchoring
// on a comp frame skews the comparison by the gap between them.
var frame = SequencePattern.FrameFromName(Path.GetFileName(local))
?? timing.FrameStart
?? renderFirstFrame;
return new TimecodeReference("manifest", local, header.Timecode.Value, frame, handleFrames,
header.FramesPerSecond);
}
_log.LogWarning("Timing plate from manifest is unreadable: {Path}", local);
} }
// Rank 2 — derive the plate from a configured search root. // Rank 2 — derive the plate from a configured search root.
@@ -469,6 +494,63 @@ public sealed class ValidationStage
return null; return null;
} }
private static TimecodeReference? ReadManifestPlate(PlateRef plate, PathMapper mapper, int handleFrames, int renderFirstFrame)
{
var local = mapper.Map(plate.Path);
var header = File.Exists(local) ? ExrHeader.TryRead(local) : null;
if (header?.Timecode is null) return null;
// The plate's own file numbering, never the comp's frame range: the
// render's first frame is in output numbering, so anchoring on a comp
// frame skews the comparison by the gap between them.
var frame = SequencePattern.FrameFromName(Path.GetFileName(local))
?? plate.FrameStart
?? renderFirstFrame;
return new TimecodeReference("manifest", local, header.Timecode.Value, frame, handleFrames,
header.FramesPerSecond);
}
/// <summary>
/// The manifest's other delivered plates, tried when the timing plate does
/// not match. Only real footage qualifies — under a configured plate search
/// root or, with none configured, alongside the timing plate in its footage
/// folder — because plates[] is every file in the comp, and a pre-render
/// agrees with the render whether or not either is right.
/// </summary>
private IEnumerable<TimecodeReference> ResolveAlternatePlates(RenderManifest m, int renderFirstFrame, TimecodeReference timingPlate)
{
var plates = m.Source?.Plates;
if (plates is null || plates.Count == 0 || timingPlate.PlatePath is null) yield break;
var mapper = new PathMapper(_options.PathMappings);
static string AsFolder(string dir) => Path.TrimEndingDirectorySeparator(Path.GetFullPath(dir)) + Path.DirectorySeparatorChar;
var deliveredRoots = _options.PlateSearchRoots.Count > 0
? _options.PlateSearchRoots.Select(r => AsFolder(mapper.Map(r))).ToList()
// {footage}/{shot}_{element}/file.exr or {footage}/{shot}/{element}/file.exr:
// two levels up from the timing plate is the folder its siblings share.
: Path.GetDirectoryName(Path.GetDirectoryName(Path.GetFullPath(timingPlate.PlatePath))) is { } footage
? new List<string> { AsFolder(footage) }
: new List<string>();
var seen = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { Path.GetFullPath(timingPlate.PlatePath) };
foreach (var plate in plates)
{
if (string.IsNullOrWhiteSpace(plate.Path)) continue;
var local = Path.GetFullPath(mapper.Map(plate.Path));
if (!seen.Add(local)) continue;
if (!deliveredRoots.Any(root => local.StartsWith(root, StringComparison.OrdinalIgnoreCase))) continue;
var reference = ReadManifestPlate(plate, mapper, timingPlate.HandleFrames, renderFirstFrame);
if (reference is null)
{
_log.LogWarning("Alternate plate from manifest is unreadable: {Path}", local);
continue;
}
yield return reference;
}
}
/// <summary> /// <summary>
/// Rank 2: look for the shot's plate folders under the configured roots, /// Rank 2: look for the shot's plate folders under the configured roots,
/// mirroring the panel's two on-disk layouts ({shotCode}/{element}/ and /// mirroring the panel's two on-disk layouts ({shotCode}/{element}/ and
@@ -645,6 +727,16 @@ public sealed class SequencePattern
return new SequencePattern { Prefix = prefix, Extension = ext, Padding = padding }; return new SequencePattern { Prefix = prefix, Extension = ext, Padding = padding };
} }
/// <summary>
/// Whether a filename belongs to *this* render's output: the pattern's own
/// prefix and extension. A version folder also holds the preview MOV and
/// MP4, which are built from the same basename and so share the prefix —
/// only the extension separates them from the frames.
/// </summary>
public bool MatchesOutputFile(string fileName) =>
fileName.StartsWith(Prefix, StringComparison.OrdinalIgnoreCase)
&& fileName.EndsWith(Extension, StringComparison.OrdinalIgnoreCase);
public int? FrameNumberOf(string fileName) => FrameFromName(fileName); public int? FrameNumberOf(string fileName) => FrameFromName(fileName);
/// <summary>`UNG_102_019_010_cmp_TT_v005.01001.exr` → 1001.</summary> /// <summary>`UNG_102_019_010_cmp_TT_v005.01001.exr` → 1001.</summary>
@@ -35,6 +35,12 @@ public sealed class WorkerOptions
/// </summary> /// </summary>
public List<string> PlateSearchRoots { get; set; } = new(); public List<string> PlateSearchRoots { get; set; } = new();
/// <summary> /// <summary>
/// Parallel connections per large upload. From the studio each connection
/// to object storage is capped near 0.1 MB/s, so throughput scales with
/// this (measured: 1 → 0.13 MB/s, 8 → 0.64, 24 → 1.69).
/// </summary>
public int UploadConcurrency { get; set; } = 16;
/// <summary>
/// Read from the assembly, not from config.json: a hand-maintained version /// Read from the assembly, not from config.json: a hand-maintained version
/// string is exactly the thing that goes stale, and a machine reporting a /// string is exactly the thing that goes stale, and a machine reporting a
/// version it is not running is worse than no version at all. /// version it is not running is worse than no version at all.
@@ -15,6 +15,7 @@ public sealed class WorkerService : BackgroundService
private readonly ApiClient _api; private readonly ApiClient _api;
private readonly JobExecutor _executor; private readonly JobExecutor _executor;
private readonly ReportSpooler _spooler; private readonly ReportSpooler _spooler;
private readonly HighResUploader _highRes;
private readonly ILogger<WorkerService> _log; private readonly ILogger<WorkerService> _log;
private string? _machineId; private string? _machineId;
@@ -23,8 +24,10 @@ public sealed class WorkerService : BackgroundService
private CancellationTokenSource? _cancelCurrentJob; private CancellationTokenSource? _cancelCurrentJob;
private bool? _lastAeOpen; private bool? _lastAeOpen;
public WorkerService(WorkerOptions options, ApiClient api, JobExecutor executor, ReportSpooler spooler, ILogger<WorkerService> log) public WorkerService(WorkerOptions options, ApiClient api, JobExecutor executor, ReportSpooler spooler,
HighResUploader highRes, ILogger<WorkerService> log)
{ {
_highRes = highRes;
_options = options; _options = options;
_api = api; _api = api;
_executor = executor; _executor = executor;
@@ -40,6 +43,7 @@ public sealed class WorkerService : BackgroundService
_ = Task.Run(() => _spooler.RunAsync(stoppingToken), stoppingToken); _ = Task.Run(() => _spooler.RunAsync(stoppingToken), stoppingToken);
await RegisterWithRetryAsync(stoppingToken); await RegisterWithRetryAsync(stoppingToken);
_ = Task.Run(() => _highRes.RunAsync(stoppingToken), stoppingToken);
await _api.ReportVersionAsync(_options, stoppingToken); await _api.ReportVersionAsync(_options, stoppingToken);
await _executor.ReconcileAsync(_machineId!, stoppingToken); await _executor.ReconcileAsync(_machineId!, stoppingToken);
+7 -1
View File
@@ -30,7 +30,11 @@
queued: [], queued: [],
frameCount: null, frameCount: null,
width: null, width: null,
height: null height: null,
// Seconds of slate ahead of picture in the preview comp — the SHOT
// layer's in-point. The worker needs it to grab a thumbnail from
// picture rather than from the slate card.
pictureStartSeconds: null
}; };
var resultPath = null; var resultPath = null;
@@ -512,6 +516,8 @@
var shotLayer = previewComp.layer("SHOT"); var shotLayer = previewComp.layer("SHOT");
var targetOutPoint = shotLayer.inPoint + shotComp.duration; var targetOutPoint = shotLayer.inPoint + shotComp.duration;
// Everything before this is slate; the thumbnail has to start after it.
result.pictureStartSeconds = shotLayer.inPoint;
if (targetOutPoint > previewComp.duration) { if (targetOutPoint > previewComp.duration) {
previewComp.duration = targetOutPoint; previewComp.duration = targetOutPoint;
} }
+1539 -36
View File
File diff suppressed because it is too large Load Diff
+111 -5
View File
@@ -178,7 +178,7 @@ Same applies to `footageRoot`: change `V:/_FOOTAGE/UNG` → `V:/_FOOTAGE`.
The panel is divided into seven sections: The panel is divided into seven sections:
1. **Shot Builder** — Episode/shot selection and comp creation 1. **Shot Builder** — Episode/shot selection and comp creation
2. **Render Pipeline** — Queue Export, status polling, retry, regenerate previews 2. **Render Pipeline** — Queue Export, status polling, retry, regenerate previews, increment shot version
3. **QC** — Technical QC queue for rendered exports 3. **QC** — Technical QC queue for rendered exports
4. **Actions** — Per-shot and batch operations 4. **Actions** — Per-shot and batch operations
5. **Workspace** — One-time project initialisation 5. **Workspace** — One-time project initialisation
@@ -201,16 +201,37 @@ Constructs a full shot composite in the open AE project from the episode and sho
**Process:** **Process:**
1. Calls the shot lookup API to retrieve metadata (description, notes, episode, scene, etc.). 1. Calls the shot lookup API to retrieve metadata (description, notes, episode, scene, etc.).
2. If a comp with the shot code already exists, updates its overlay instead of rebuilding. 2. If a comp with the shot code already exists, updates its overlay instead of rebuilding.
3. Scans `FOOTAGE_ROOT/{episodeCode}/` for subfolders matching `{shotCode}_*` and imports each as an EXR image sequence at 24 fps. 3. Scans `FOOTAGE_ROOT/{episodeCode}/` for subfolders matching `{shotCode}_*` and imports each as an EXR image sequence, conformed to the shot's frame rate.
4. Creates a `{shotCode}_FOOTAGE` precomp containing all imported sequences, each with an OCIO Color Space Transform effect added (disabled by default). 4. Creates a `{shotCode}_FOOTAGE` precomp containing all imported sequences, each with an OCIO Color Space Transform effect added (disabled by default).
5. Creates the main `{shotCode}` comp and places the footage precomp inside it. 5. Creates the main `{shotCode}` comp and places the footage precomp inside it.
6. If a `_SHOW LUT` comp exists in the project, adds it as a collapsed layer on top. 6. Anchors both comps on the plate's start timecode — see [Start timecode](#start-timecode).
7. Calls **Add Overlay** logic to attach the `UNG_VFX_OVERLAY` comp. 7. If a `_SHOW LUT` comp exists in the project, adds it as a collapsed layer on top.
8. Organises items into `__SHOTS/{episodeCode}`, `_FOOTAGE_4K`, and `_PRECOMPS` project folders. 8. Calls **Add Overlay** logic to attach the `UNG_VFX_OVERLAY` comp.
9. Organises items into `__SHOTS/{episodeCode}`, `_FOOTAGE_4K`, and `_PRECOMPS` project folders.
If any step fails, the status line names the stage and a copyable report opens — If any step fails, the status line names the stage and a copyable report opens —
see [Diagnostics and logging](#diagnostics-and-logging). see [Diagnostics and logging](#diagnostics-and-logging).
#### Start timecode
Neither comp starts at `00:00:00:00`. Both are anchored on the plate's own start
timecode, taken from the first source that has one:
| Rank | Source | Notes |
|---|---|---|
| 1 | The first EXR's header | The `timeCode` attribute, or `timeCodeString` where the packed one is absent. Read straight off disk — no pixel decode, and no dependency on what AE chose to expose. |
| 2 | AE's footage metadata | What "New Comp from Selection" would have inherited. |
| 3 | API `timecodeStart` less `handleFrames` | The convention **Set Start Timecode** uses. Last resort: the API stores the *editorial* in-point, which is a handle-length ahead of the plate by design. |
This is the same ranking the render worker's validation uses (RenderPipeline2
§8.1a), so a comp is anchored on exactly the value its EXRs are later checked
against — a shot built from rank 3 and validated against rank 1 is how a
timecode desync gets into a delivery.
The status line and the diagnostics log both name the rank that was used, e.g.
`start frame 864108 from EXR timecode 10:00:04:12`. A plate carrying no timecode
in any rank leaves the comp at `00:00:00:00` and says so.
--- ---
## Render Pipeline ## Render Pipeline
@@ -224,6 +245,7 @@ shot record, and submits it to the farm.
|---|---| |---|---|
| **Urgent** | Priority 20 — claimable outside the render window, ahead of normal jobs | | **Urgent** | Priority 20 — claimable outside the render window, ahead of normal jobs |
| **No preview** | Renders the EXRs but builds no preview, inheriting the previous export's MOV, review MP4 and thumbnail | | **No preview** | Renders the EXRs but builds no preview, inheriting the previous export's MOV, review MP4 and thumbnail |
| **Keep AEP** | Saves a reduced copy of the project in the export's version folder (see below) |
**No preview** exists for deliverables framed differently from the review — **No preview** exists for deliverables framed differently from the review —
unscaled or un-punched-in EXRs. A preview rebuilt from those frames would be unscaled or un-punched-in EXRs. A preview rebuilt from those frames would be
@@ -234,6 +256,37 @@ package still gets a MOV.
Leave it unticked for an ordinary submission: the preview is what QC and the Leave it unticked for an ordinary submission: the preview is what QC and the
client review see. client review see.
#### Export AEP (Keep AEP)
With **Keep AEP** ticked (the default, remembered per machine), every export
keeps a copy of the project it was queued from, so the exact comp behind a
render can be reopened later:
```
{version folder}/{shotCode}_cmp_TT_{version}.aep e.g. .../UNG_102_019_010/v005/UNG_102_019_010_cmp_TT_v005.aep
```
- The copy is **reduced** to the exported comp and everything it uses (nested
comps, footage, solids). Everything else in the project is dropped.
- Nothing is collected. Plates and EXRs stay where they are and the copy links
to them by path, so it stays a few MB.
- It is saved after the export is submitted, into the same version folder the
farm renders into. The worker only reads and clears `*.exr` files there, so
the `.aep` is never touched. Re-queuing the same version overwrites it, just
as the render overwrites the EXRs.
- AE can only reduce the open project, so the panel does Save As, Reduce Project,
Save, and then **reopens your project**. Your project was saved first and is
never changed, but the reopen clears undo. Untick **Keep AEP** to skip it.
- The copy is the project as it was when you queued. The farm still renders
your working AEP, so a save made before the job starts goes into the render
but not into the copy.
- Reduce Project keeps only comps that are used as layers. An expression that
points at a comp with `comp("Name")`, where that comp isn't nested anywhere,
will break in the copy.
If the copy can't be saved, the export is still queued and the status line says
`AEP not saved: …` with the reason.
--- ---
## QC ## QC
@@ -246,10 +299,63 @@ QC is per-export: a new export always needs new QC.
|---|---| |---|---|
| **Load QC Queue** | Lists every export in `READY_FOR_QC` for the selected project, oldest first. Entries flagged with a warning count had a non-blocking validation warning worth a closer look. | | **Load QC Queue** | Lists every export in `READY_FOR_QC` for the selected project, oldest first. Entries flagged with a warning count had a non-blocking validation warning worth a closer look. |
| **Open Render** (or double-click) | Imports that export's actual EXR sequence into a `QC_{shot}_{version}` comp at full res and opens it. Re-selecting an already-imported shot just reopens the comp. | | **Open Render** (or double-click) | Imports that export's actual EXR sequence into a `QC_{shot}_{version}` comp at full res and opens it. Re-selecting an already-imported shot just reopens the comp. |
| **Compare Versions** | Opens the QC comp and stacks earlier versions of the shot under the export, one layer each (`v003`, `v002`…), lined up by EXR timecode (or frame number). Solo a layer to see that version, or set the top layer to **Difference** to see exactly what changed. With more than one earlier version, a dialog lets you untick the ones you don't need. Versions already in the comp are skipped. |
| **Build QC Review Session** | Lays out the whole project's QC pass in one go. Every shot in the queue gets its `QC_{shot}_{version}` comp, and each scene gets an edit and a contact sheet. See *QC review session* below. |
| **Notes** | Sent with the decision. Optional on pass; a fail with no notes asks for confirmation, because the artist only sees what you write here. | | **Notes** | Sent with the decision. Optional on pass; a fail with no notes asks for confirmation, because the artist only sees what you write here. |
| **QC Pass** | Marks the version **ready for delivery** and nothing else — nothing is shared to the client, no approval state changes, no task moves. | | **QC Pass** | Marks the version **ready for delivery** and nothing else — nothing is shared to the client, no approval state changes, no task moves. |
| **QC Fail** | Sets the export to `QC_FAILED` and the comp task to **CHANGES**. The artist fixes and queues a new version; the old export is superseded. | | **QC Fail** | Sets the export to `QC_FAILED` and the comp task to **CHANGES**. The artist fixes and queues a new version; the old export is superseded. |
**Where Compare Versions looks:** next to the export's own render folder (resolved
as for Open Render), in both on-disk layouts. That means farm version folders
(`{shot}/v002/`, `{shot}/v003/`…) and the older flat folder with
`{shot}_cmp_TT_{ver}.#####.exr` side by side. Only versions numbered below the
export's are used. If earlier exports were written under a different root (see
*More than one on-disk convention*), they won't be found.
### QC review session
**Build QC Review Session** loads the queue for the selected project. A dialog
lists its scenes. Ctrl-click a scene to leave it out, or untick *Also import
earlier versions*. Everything is built in one undo step, under
`QC_SESSION_{project}` in the Project panel:
| Item | What it is |
|---|---|
| `{scene}/shots/QC_{shot}_{version}` | One comp per shot, reusing the comp from Open Render if there is one. The export sits on top, earlier versions under it (`v003`, `v002`…), and the shot's plates at the bottom, found as Build Shot finds them. **Only the export and the main plate (the longest) are switched on.** |
| `{scene}/QC_EDIT_{scene}` | The scene's shot comps as one continuous edit. Each shot is cut to the edit, with the handles the render carries trimmed off, and has a layer marker with its name. |
| `{scene}/QC_CONTACT_{scene}` | Every shot of the scene in a grid, each starting at its cut in, with its name under it. |
| `_footage` | The EXR sequences it imported. Plates already in the project are reused, not imported again. |
A scene is the shot record's scene, which is not always the scene in the shot
code. Episodic shows group by episode too (`UNG_109_SC013`), and standard ones
by show (`DH2_VFX_SC033`). Shots run in sequence-timecode order when every shot
in the scene has one, and in shot-code order otherwise. Only the newest queued
version of a shot gets a comp; older queued versions appear as earlier versions
in it.
Plates and earlier versions are lined up with the export by EXR timecode. A
timecode more than a shot's length away is ignored, because a shot's elements
can carry unrelated camera timecodes. The file frame number is used next, then
the export's first frame. Exports from before handles were recorded have no
handle count, so they play in full in the edit, and the status line counts them.
Running the button again adds anything new to the shot comps and rebuilds the
scene edits and contact sheets from scratch. Don't do your own work in those
two comps.
**Approving from the session.** QC Pass and QC Fail act on the shot in front of
you, without finding it in the list:
- the `QC_{shot}_{version}` comp in the viewer, or
- the shot layer (or its label) selected in a scene edit or contact sheet, or
- with nothing selected in a scene edit, the shot under the playhead.
The confirmation names the shot, and a fail with notes is confirmed too when it
came from the viewer. If a scene comp is active and no shot is picked, nothing
is sent. Pick a shot, or switch to another comp to use the list selection. After
a decision, that shot's comp and its layers in the scene comps are labelled
**green** (pass) or **red** (fail).
Passing an export is what makes it eligible for a delivery package on the web Passing an export is what makes it eligible for a delivery package on the web
app's **Pipeline → Deliveries** page. app's **Pipeline → Deliveries** page.
+1 -1
View File
@@ -14,7 +14,7 @@ const saveAnnotationSchema = z.object({
shapes: z.array(z.any()), shapes: z.array(z.any()),
canvasWidth: z.number(), canvasWidth: z.number(),
canvasHeight: z.number(), canvasHeight: z.number(),
version: z.literal("1.0"), version: z.enum(["1.0", "2.0"]),
}), }),
color: z.string().default("#ef4444"), color: z.string().default("#ef4444"),
}); });
+24 -14
View File
@@ -5,7 +5,7 @@ import { db } from "@/lib/db";
import { revalidatePath } from "next/cache"; import { revalidatePath } from "next/cache";
import { z } from "zod"; import { z } from "zod";
import { ApprovalStatus } from "@prisma/client"; import { ApprovalStatus } from "@prisma/client";
import { recalcShotStatus } from "@/lib/shot-status"; import { recalcShotStatus, clearStaleShotApproval } from "@/lib/shot-status";
import { notifyApprovalChange } from "@/lib/notifications"; import { notifyApprovalChange } from "@/lib/notifications";
import { slackNotifyApproval } from "@/lib/slack"; import { slackNotifyApproval } from "@/lib/slack";
import { versionLabel } from "@/lib/utils"; import { versionLabel } from "@/lib/utils";
@@ -29,8 +29,11 @@ export async function submitApproval(data: z.infer<typeof approvalSchema>) {
throw new Error("Insufficient permissions to review versions"); throw new Error("Insufficient permissions to review versions");
} }
// Create the approval record // The verdict, the version, the task and the derived shot status are one
const approval = await db.approval.create({ // decision and are written as one: a failure partway through used to leave the
// three layers disagreeing, with no way to tell which one was right.
const { approval, version } = await db.$transaction(async (tx) => {
const approval = await tx.approval.create({
data: { data: {
versionId: parsed.versionId, versionId: parsed.versionId,
userId: session.user.id, userId: session.user.id,
@@ -39,14 +42,13 @@ export async function submitApproval(data: z.infer<typeof approvalSchema>) {
}, },
}); });
// Update version approval status await tx.version.update({
await db.version.update({
where: { id: parsed.versionId }, where: { id: parsed.versionId },
data: { approvalStatus: parsed.status }, data: { approvalStatus: parsed.status },
}); });
// Load version + task + shot + project for downstream effects // Load version + task + shot + project for downstream effects
const version = await db.version.findUnique({ const version = await tx.version.findUnique({
where: { id: parsed.versionId }, where: { id: parsed.versionId },
include: { include: {
task: { task: {
@@ -63,12 +65,12 @@ export async function submitApproval(data: z.infer<typeof approvalSchema>) {
// Update task status based on approval result // Update task status based on approval result
if (version.task && parsed.status !== "PENDING_REVIEW") { if (version.task && parsed.status !== "PENDING_REVIEW") {
if (parsed.status === "APPROVED") { if (parsed.status === "APPROVED") {
await db.task.update({ await tx.task.update({
where: { id: version.task.id }, where: { id: version.task.id },
data: { status: "DONE" }, data: { status: "DONE" },
}); });
} else if (parsed.status === "REJECTED" || parsed.status === "NEEDS_CHANGES") { } else if (parsed.status === "REJECTED" || parsed.status === "NEEDS_CHANGES") {
await db.task.update({ await tx.task.update({
where: { id: version.task.id }, where: { id: version.task.id },
data: { status: "CHANGES" }, data: { status: "CHANGES" },
}); });
@@ -76,10 +78,13 @@ export async function submitApproval(data: z.infer<typeof approvalSchema>) {
// Recalculate shot status from updated task states // Recalculate shot status from updated task states
if (version.task.shot) { if (version.task.shot) {
await recalcShotStatus(version.task.shot.id).catch(() => {}); await recalcShotStatus(version.task.shot.id, tx);
} }
} }
return { approval, version };
});
// Notifications // Notifications
const reviewer = await db.user.findUnique({ where: { id: session.user.id } }); const reviewer = await db.user.findUnique({ where: { id: session.user.id } });
const reviewerName = reviewer?.name ?? "Reviewer"; const reviewerName = reviewer?.name ?? "Reviewer";
@@ -166,8 +171,10 @@ export async function unapproveVersion(versionId: string) {
throw new Error("Only approved versions can be unapproved"); throw new Error("Only approved versions can be unapproved");
} }
// One decision, one write — same reasoning as submitApproval.
await db.$transaction(async (tx) => {
// Create an audit record for the unapproval // Create an audit record for the unapproval
await db.approval.create({ await tx.approval.create({
data: { data: {
versionId, versionId,
userId: session.user.id, userId: session.user.id,
@@ -177,23 +184,26 @@ export async function unapproveVersion(versionId: string) {
}); });
// Reset version approval status // Reset version approval status
await db.version.update({ await tx.version.update({
where: { id: versionId }, where: { id: versionId },
data: { approvalStatus: "PENDING_REVIEW" }, data: { approvalStatus: "PENDING_REVIEW" },
}); });
// Reset task back to INTERNAL_REVIEW if it was moved to DONE // Reset task back to INTERNAL_REVIEW if it was moved to DONE
if (version.task && version.task.status === "DONE") { if (version.task && version.task.status === "DONE") {
await db.task.update({ await tx.task.update({
where: { id: version.task.id }, where: { id: version.task.id },
data: { status: "INTERNAL_REVIEW" }, data: { status: "INTERNAL_REVIEW" },
}); });
} }
// Recalculate shot status // Undoing a version approval also invalidates any shot-level sign-off that
// rested on it, otherwise the shot keeps reading COMPLETE / READY_FOR_CLIENT.
if (version.task?.shot) { if (version.task?.shot) {
await recalcShotStatus(version.task.shot.id).catch(() => {}); await clearStaleShotApproval(tx, version.task.shot.id);
await recalcShotStatus(version.task.shot.id, tx);
} }
});
revalidatePath(`/review/${versionId}`); revalidatePath(`/review/${versionId}`);
if (version.task) { if (version.task) {
+196
View File
@@ -0,0 +1,196 @@
"use server";
import { auth } from "@/auth";
import { db } from "@/lib/db";
import { revalidatePath } from "next/cache";
import { z } from "zod";
import { findShot, parseBoardText } from "@/lib/board-parse";
// The board is studio-internal. Anyone on staff can add and tick off lines;
// it is a shared to-do list, not an approval surface.
async function requireStaff() {
const session = await auth();
if (!session?.user) throw new Error("Unauthorized");
if (session.user.role === "CLIENT") throw new Error("Insufficient permissions");
return session.user;
}
async function boardContext(projectId: string) {
const [shots, users] = await Promise.all([
db.shot.findMany({
where: { projectId },
select: { id: true, shotCode: true, clientCode: true },
}),
db.user.findMany({
where: { isActive: true, role: { not: "CLIENT" } },
select: { id: true, name: true, email: true },
}),
]);
return { shots, users };
}
const addSchema = z.object({
projectId: z.string().cuid(),
input: z.string().min(1).max(20000),
group: z.string().max(100).optional(),
});
/** Adds one line, or a pasted block of lines, to a project's board. */
export async function addBoardItems(data: z.infer<typeof addSchema>) {
const user = await requireStaff();
const parsed = addSchema.parse(data);
const items = parseBoardText(parsed.input, {
...(await boardContext(parsed.projectId)),
group: parsed.group,
});
if (items.length === 0) return { success: true, added: 0, unmatched: [] as string[] };
const last = await db.boardItem.findFirst({
where: { projectId: parsed.projectId },
orderBy: { sortOrder: "desc" },
select: { sortOrder: true },
});
const base = (last?.sortOrder ?? -1) + 1;
await db.boardItem.createMany({
data: items.map((item, i) => ({
projectId: parsed.projectId,
shotId: item.shotId,
code: item.code,
text: item.text,
group: item.group,
assigneeId: item.assigneeId,
waitingOn: item.waitingOn,
sortOrder: base + i,
createdById: user.id,
})),
});
revalidatePath("/board");
return {
success: true,
added: items.length,
unmatched: items.filter((i) => i.code && !i.shotId).map((i) => i.code as string),
};
}
const updateSchema = z.object({
text: z.string().max(5000).optional(),
code: z.string().max(100).nullable().optional(),
group: z.string().max(100).optional(),
assigneeId: z.string().cuid().nullable().optional(),
waitingOn: z.string().max(500).nullable().optional(),
});
export async function updateBoardItem(id: string, data: z.infer<typeof updateSchema>) {
await requireStaff();
const parsed = updateSchema.parse(data);
const item = await db.boardItem.findUnique({ where: { id }, select: { projectId: true } });
if (!item) throw new Error("Board item not found");
// Changing the code re-links the line; a code that matches nothing is kept
// as a flag, exactly as when it was first typed.
let link: { code: string | null; shotId: string | null } | undefined;
if (parsed.code !== undefined) {
const code = parsed.code?.trim() || null;
const shot = code ? findShot(code, (await boardContext(item.projectId)).shots) : null;
link = { code: shot?.shotCode ?? code?.toUpperCase() ?? null, shotId: shot?.id ?? null };
}
await db.boardItem.update({
where: { id },
data: {
...(parsed.text !== undefined && { text: parsed.text.trim() }),
...(parsed.group !== undefined && { group: parsed.group.trim() }),
...(parsed.assigneeId !== undefined && { assigneeId: parsed.assigneeId }),
...(parsed.waitingOn !== undefined && { waitingOn: parsed.waitingOn?.trim() || null }),
...link,
},
});
revalidatePath("/board");
return { success: true };
}
export async function setBoardItemDone(id: string, done: boolean) {
const user = await requireStaff();
const item = await db.boardItem.update({
where: { id },
data: done ? { doneAt: new Date(), doneById: user.id } : { doneAt: null, doneById: null },
select: { commentId: true },
});
// A line from pasted feedback is that client note: ticking it off resolves
// the comment in the player too. (The comment may have been deleted there.)
if (item.commentId) {
const comment = await db.comment.updateMany({
where: { id: item.commentId },
data: { isResolved: done },
});
if (comment.count) {
const c = await db.comment.findUnique({ where: { id: item.commentId }, select: { versionId: true } });
if (c) revalidatePath(`/review/${c.versionId}`);
}
}
revalidatePath("/board");
return { success: true };
}
export async function deleteBoardItem(id: string) {
await requireStaff();
await db.boardItem.delete({ where: { id } });
revalidatePath("/board");
return { success: true };
}
const statusSchema = z.object({
projectId: z.string().cuid(),
status: z.string().max(2000),
});
export async function setProjectBoardStatus(data: z.infer<typeof statusSchema>) {
await requireStaff();
const parsed = statusSchema.parse(data);
const status = parsed.status.trim() || null;
await db.project.update({
where: { id: parsed.projectId },
data: { boardStatus: status, boardStatusAt: status ? new Date() : null },
});
revalidatePath("/board");
return { success: true };
}
const milestoneSchema = z.object({
projectId: z.string().cuid(),
label: z.string().min(1).max(200),
date: z.string().min(1),
});
export async function addMilestone(data: z.infer<typeof milestoneSchema>) {
await requireStaff();
const parsed = milestoneSchema.parse(data);
const date = new Date(parsed.date);
if (isNaN(date.getTime())) throw new Error("Invalid date");
await db.projectMilestone.create({
data: { projectId: parsed.projectId, label: parsed.label.trim(), date },
});
revalidatePath("/board");
return { success: true };
}
export async function setMilestoneDone(id: string, done: boolean) {
await requireStaff();
await db.projectMilestone.update({
where: { id },
data: { doneAt: done ? new Date() : null },
});
revalidatePath("/board");
return { success: true };
}
export async function deleteMilestone(id: string) {
await requireStaff();
await db.projectMilestone.delete({ where: { id } });
revalidatePath("/board");
return { success: true };
}
+43
View File
@@ -0,0 +1,43 @@
"use server";
import { revalidatePath } from "next/cache";
import { requirePipelineAdmin } from "@/lib/render-pipeline/session-auth";
import { PipelineError } from "@/lib/render-pipeline/errors";
import {
createMovReviewPackage,
previewMovReviewPackage,
} from "@/lib/render-pipeline/reviews";
/**
* Server actions behind "Build MOV Review Package" on the shot-status page
* (RenderPipeline2 §11.6). The heavy lifting lives in lib/render-pipeline;
* these only carry the session and turn service errors into messages a toast
* can show.
*/
function message(err: unknown): string {
if (err instanceof PipelineError) return err.message;
return err instanceof Error ? err.message : "Unknown error";
}
/** What the confirm dialog shows: the folder, the resolved versions, the gaps. */
export async function previewMovReview(shotIds: string[]) {
try {
await requirePipelineAdmin();
const preview = await previewMovReviewPackage(shotIds);
return { ok: true as const, ...preview };
} catch (err) {
return { ok: false as const, error: message(err) };
}
}
export async function buildMovReview(shotIds: string[]) {
try {
const user = await requirePipelineAdmin();
const result = await createMovReviewPackage({ shotIds }, user.id);
revalidatePath("/pipeline/deliveries");
return { ok: true as const, ...result };
} catch (err) {
return { ok: false as const, error: message(err) };
}
}
+253
View File
@@ -0,0 +1,253 @@
"use server";
import { auth } from "@/auth";
import { db } from "@/lib/db";
import { revalidatePath } from "next/cache";
import { z } from "zod";
import { findShot, suggestShot, type BoardShot } from "@/lib/board-parse";
import { parseFeedback, slateFrames, toPlayerFrame } from "@/lib/feedback-parse";
import { updateTaskStatus } from "@/actions/tasks";
/** Comment.source for notes pasted from a client message */
const SOURCE = "WHATSAPP";
async function requireStaff() {
const session = await auth();
if (!session?.user) throw new Error("Unauthorized");
if (session.user.role === "CLIENT") throw new Error("Insufficient permissions");
return session.user;
}
/**
* The shot a pasted code means: exact code or client alias first, then a code
* the client shortened by dropping the show prefix ("113_018_040" for
* "UNG_113_018_040") when exactly one shot ends with it.
*/
function resolveShot<T extends BoardShot>(code: string, shots: T[]): T | null {
const exact = findShot(code, shots) as T | null;
if (exact) return exact;
const tail = `_${code.toUpperCase()}`;
const hits = shots.filter((s) => s.shotCode.toUpperCase().endsWith(tail));
return hits.length === 1 ? hits[0] : null;
}
export interface FeedbackVersionOption {
id: string;
label: string;
sent: boolean;
sharedAt: string | null;
taskId: string | null;
taskStatus: string | null;
/** The note's quoted frame converted for this version's media; null = no frame quoted */
playerFrame: number | null;
fromComp: boolean;
}
export interface FeedbackPreviewNote {
key: string;
code: string;
text: string;
quotedFrame: number | null;
shot: { id: string; shotCode: string } | null;
suggestion: string | null;
versions: FeedbackVersionOption[];
defaultVersionId: string | null;
}
export interface FeedbackPreview {
rounds: { title: string; dueText: string | null; notes: FeedbackPreviewNote[] }[];
ignored: string[];
}
export async function previewFeedback(projectId: string, input: string): Promise<FeedbackPreview> {
await requireStaff();
z.string().cuid().parse(projectId);
const parsed = parseFeedback(z.string().max(50000).parse(input));
const shots = await db.shot.findMany({
where: { projectId },
select: { id: true, shotCode: true, clientCode: true, frameStart: true },
});
const matched = new Map<string, (typeof shots)[number] | null>();
for (const r of parsed.rounds) for (const n of r.notes) {
const code = n.codes[0];
if (!matched.has(code)) matched.set(code, resolveShot(code, shots));
}
const shotIds = [...new Set([...matched.values()].filter(Boolean).map((s) => s!.id))];
// Recent versions per shot, whether hung off the shot or its task
const versions = shotIds.length
? await db.version.findMany({
where: { OR: [{ shotId: { in: shotIds } }, { task: { shotId: { in: shotIds } } }] },
orderBy: { createdAt: "desc" },
select: {
id: true,
versionNumber: true,
shotId: true,
isClientVisible: true,
sharedAt: true,
frameCount: true,
pictureStartFrame: true,
task: { select: { id: true, status: true, shotId: true } },
},
})
: [];
const byShot = new Map<string, typeof versions>();
for (const v of versions) {
const sid = v.shotId ?? v.task?.shotId;
if (!sid) continue;
const list = byShot.get(sid) ?? [];
if (list.length < 6) list.push(v);
byShot.set(sid, list);
}
let k = 0;
return {
ignored: parsed.ignored,
rounds: parsed.rounds.map((r) => ({
title: r.title,
dueText: r.dueText,
notes: r.notes.map((n) => {
const code = n.codes[0];
const shot = matched.get(code) ?? null;
const options: FeedbackVersionOption[] = (shot ? byShot.get(shot.id) ?? [] : []).map((v) => {
const conv = n.frame != null
? toPlayerFrame(n.frame, {
shotFrameStart: shot!.frameStart,
pictureStart: slateFrames(v),
frameCount: v.frameCount,
})
: null;
return {
id: v.id,
label: `v${String(v.versionNumber).padStart(3, "0")}`,
sent: v.isClientVisible,
sharedAt: v.sharedAt?.toISOString() ?? null,
taskId: v.task?.id ?? null,
taskStatus: v.task?.status ?? null,
playerFrame: conv?.frame ?? null,
fromComp: conv?.fromComp ?? false,
};
});
// The client is commenting on what they were sent
const def = options.find((o) => o.sent) ?? options[0] ?? null;
return {
key: `n${k++}`,
code: shot?.shotCode ?? code,
text: n.text,
quotedFrame: n.frame,
shot: shot ? { id: shot.id, shotCode: shot.shotCode } : null,
suggestion: shot ? null : suggestShot(code, shots)?.shotCode ?? null,
versions: options,
defaultVersionId: def?.id ?? null,
};
}),
})),
};
}
const commitSchema = z.object({
projectId: z.string().cuid(),
rounds: z.array(z.object({
title: z.string().max(200),
dueAt: z.string().datetime().nullable(),
notes: z.array(z.object({
code: z.string().min(1).max(100),
shotId: z.string().cuid().nullable(),
text: z.string().min(1).max(5000),
versionId: z.string().cuid().nullable(),
frame: z.number().int().min(0).nullable(),
setChanges: z.boolean(),
})).min(1),
})).min(1),
});
/**
* Saves pasted client feedback: one FeedbackRound per round, each note as a
* player comment (tagged as client feedback) and a board line, and — where
* ticked — the version's task moved to Changes.
*/
export async function commitFeedback(data: z.infer<typeof commitSchema>) {
const user = await requireStaff();
const parsed = commitSchema.parse(data);
const notes = parsed.rounds.flatMap((r) => r.notes);
const versionIds = [...new Set(notes.map((n) => n.versionId).filter(Boolean) as string[])];
const versions = await db.version.findMany({
where: { id: { in: versionIds } },
select: { id: true, fps: true, shotId: true, task: { select: { id: true, shotId: true, status: true, projectId: true } }, shot: { select: { projectId: true } } },
});
const vById = new Map(versions.map((v) => [v.id, v]));
for (const n of notes) {
if (!n.versionId) continue;
const v = vById.get(n.versionId);
const projectOk = v && (v.shot?.projectId ?? v.task?.projectId) === parsed.projectId;
const shotOk = v && (v.shotId ?? v.task?.shotId) === n.shotId;
if (!projectOk || !shotOk) throw new Error(`Version does not belong to ${n.code}`);
}
const last = await db.boardItem.findFirst({
where: { projectId: parsed.projectId },
orderBy: { sortOrder: "desc" },
select: { sortOrder: true },
});
let sort = (last?.sortOrder ?? -1) + 1;
let comments = 0;
await db.$transaction(async (tx) => {
for (const r of parsed.rounds) {
const round = await tx.feedbackRound.create({
data: {
projectId: parsed.projectId,
title: r.title.trim() || "Client feedback",
dueAt: r.dueAt ? new Date(r.dueAt) : null,
createdById: user.id,
},
});
for (const n of r.notes) {
const v = n.versionId ? vById.get(n.versionId)! : null;
const frame = n.frame ?? 0;
const comment = v
? await tx.comment.create({
data: {
versionId: v.id,
authorId: user.id,
frameNumber: frame,
timestamp: frame / v.fps,
text: n.text.trim(),
source: SOURCE,
},
select: { id: true },
})
: null;
if (comment) comments++;
await tx.boardItem.create({
data: {
projectId: parsed.projectId,
shotId: n.shotId,
code: n.code.toUpperCase(),
text: n.text.trim(),
roundId: round.id,
commentId: comment?.id ?? null,
sortOrder: sort++,
createdById: user.id,
},
});
}
}
});
// Outside the transaction: updateTaskStatus notifies the artist and
// recalculates shot status, exactly as moving the task by hand does.
const tasks = new Set<string>();
for (const n of notes) {
const task = n.versionId ? vById.get(n.versionId)?.task : null;
if (n.setChanges && task && task.status !== "CHANGES") tasks.add(task.id);
}
for (const taskId of tasks) await updateTaskStatus(taskId, "CHANGES");
for (const id of versionIds) revalidatePath(`/review/${id}`);
revalidatePath("/board");
return { success: true, notes: notes.length, comments, tasksChanged: tasks.size };
}
+5 -1
View File
@@ -108,10 +108,14 @@ export async function updateProject(data: z.infer<typeof updateProjectSchema>) {
...(rest.slackChannel !== undefined && { slackChannel: rest.slackChannel || null }), ...(rest.slackChannel !== undefined && { slackChannel: rest.slackChannel || null }),
// Blank fields are dropped rather than stored as empty strings, so a comp // Blank fields are dropped rather than stored as empty strings, so a comp
// name left blank keeps following the convention instead of pinning "". // name left blank keeps following the convention instead of pinning "".
// Booleans are kept as-is: `false` is a meaningful stored value, and the
// blank-string test would otherwise discard every non-string setting.
...(rest.pipelineConfig !== undefined && { ...(rest.pipelineConfig !== undefined && {
pipelineConfig: rest.pipelineConfig pipelineConfig: rest.pipelineConfig
? (Object.fromEntries( ? (Object.fromEntries(
Object.entries(rest.pipelineConfig).filter(([, v]) => typeof v === "string" && v.trim()) Object.entries(rest.pipelineConfig).filter(([, v]) =>
typeof v === "boolean" ? true : typeof v === "string" && !!v.trim()
)
) as Prisma.InputJsonValue) ) as Prisma.InputJsonValue)
: Prisma.DbNull, : Prisma.DbNull,
}), }),
+361 -40
View File
@@ -4,8 +4,9 @@ import { auth } from "@/auth";
import { db } from "@/lib/db"; import { db } from "@/lib/db";
import { revalidatePath } from "next/cache"; import { revalidatePath } from "next/cache";
import { z } from "zod"; import { z } from "zod";
import { ShotStatus, ShotPriority, ShotApprovalStatus } from "@prisma/client"; import { ShotStatus, ShotPriority, ShotApprovalStatus, Prisma } from "@prisma/client";
import { recalcShotStatus } from "@/lib/shot-status"; import { recalcShotStatus, markShotForRevisions } from "@/lib/shot-status";
import { countShotsOnOpenRequests } from "@/lib/render-pipeline/delivery-requests";
const createShotSchema = z.object({ const createShotSchema = z.object({
scene: z.string().min(1).max(50).regex(/^[A-Z0-9_]+$/i, "Alphanumeric and underscore only"), scene: z.string().min(1).max(50).regex(/^[A-Z0-9_]+$/i, "Alphanumeric and underscore only"),
@@ -341,6 +342,15 @@ export async function importShotsFromCsv(
return { success: true, created, errors }; return { success: true, created, errors };
} }
/**
* Manual override of the shot's status.
*
* Deliberately the one place that writes Shot.status without deriving it — but
* note the override is transient: Shot.status is a derived field, so the next
* recalc (any task move, approval, upload or render) recomputes it from the
* tasks and approval flags and discards whatever was set here. Change the
* underlying task states if the new status needs to stick.
*/
export async function updateShotStatus( export async function updateShotStatus(
shotId: string, shotId: string,
status: ShotStatus status: ShotStatus
@@ -498,6 +508,7 @@ export async function updateShotSlate(
slateDescription?: string | null; slateDescription?: string | null;
slateVfxScope?: string | null; slateVfxScope?: string | null;
slateSubmissionNote?: string | null; slateSubmissionNote?: string | null;
clientCode?: string | null;
} }
) { ) {
const session = await auth(); const session = await auth();
@@ -516,6 +527,7 @@ export async function updateShotSlate(
slateDescription: data.slateDescription !== undefined ? (data.slateDescription?.trim() || null) : undefined, slateDescription: data.slateDescription !== undefined ? (data.slateDescription?.trim() || null) : undefined,
slateVfxScope: data.slateVfxScope !== undefined ? (data.slateVfxScope?.trim() || null) : undefined, slateVfxScope: data.slateVfxScope !== undefined ? (data.slateVfxScope?.trim() || null) : undefined,
slateSubmissionNote: data.slateSubmissionNote !== undefined ? (data.slateSubmissionNote?.trim() || null) : undefined, slateSubmissionNote: data.slateSubmissionNote !== undefined ? (data.slateSubmissionNote?.trim() || null) : undefined,
clientCode: data.clientCode !== undefined ? (data.clientCode?.trim() || null) : undefined,
}, },
}); });
@@ -548,6 +560,34 @@ export async function toggleKeyShot(shotId: string, isKeyShot: boolean) {
return { success: true }; return { success: true };
} }
/**
* Scaled in the edit: the plate is not used at its native size, which changes
* how the shot is comped and reviewed. Same shape as toggleKeyShot — a standing
* property of the shot, flipped from the shot-status board.
*/
export async function toggleScaledShot(shotId: string, isScaled: boolean) {
const session = await auth();
if (!session?.user) throw new Error("Unauthorized");
if (!["ADMIN", "PRODUCER", "SUPERVISOR"].includes(session.user.role)) {
throw new Error("Insufficient permissions");
}
const shot = await db.shot.findUnique({
where: { id: shotId },
select: { projectId: true },
});
if (!shot) throw new Error("Shot not found");
await db.shot.update({
where: { id: shotId },
data: { isScaled },
});
revalidatePath(`/projects/${shot.projectId}`);
revalidatePath(`/shot-status`);
return { success: true };
}
export async function deleteShot(shotId: string) { export async function deleteShot(shotId: string) {
const session = await auth(); const session = await auth();
if (!session?.user) throw new Error("Unauthorized"); if (!session?.user) throw new Error("Unauthorized");
@@ -613,6 +653,203 @@ export async function bulkUpdateDueDates(
return { success: true, updated: shots.length }; return { success: true, updated: shots.length };
} }
// ── Bulk Assign Artist ────────────────────────────────────────────────────────
/**
* Point a selection of shots at one artist, or clear the assignment when
* `artistId` is null. Mirrors the single-shot artist field in updateShot —
* the assignment is a plain column write with no notification, so reassigning
* a batch during planning stays quiet.
*/
export async function bulkAssignArtist(shotIds: string[], artistId: string | null) {
const session = await auth();
if (!session?.user) throw new Error("Unauthorized");
if (!["ADMIN", "PRODUCER", "SUPERVISOR"].includes(session.user.role)) {
throw new Error("Insufficient permissions");
}
const ids = z.array(z.string().cuid()).parse(shotIds);
if (!ids.length) return { success: true, updated: 0, artistName: null as string | null };
let artistName: string | null = null;
if (artistId) {
const artist = await db.user.findUnique({
where: { id: z.string().cuid().parse(artistId) },
select: { id: true, name: true, email: true, role: true, isActive: true },
});
// A deactivated user or a client account must never end up owning a shot,
// so this is checked here rather than trusting whatever the picker sent.
if (!artist || !artist.isActive || artist.role === "CLIENT") {
throw new Error("That user cannot be assigned shots");
}
artistName = artist.name ?? artist.email;
}
const shots = await db.shot.findMany({
where: { id: { in: ids } },
select: { id: true, projectId: true },
});
if (shots.length !== ids.length) throw new Error("Some shots not found");
await db.shot.updateMany({
where: { id: { in: ids } },
data: { artistId },
});
for (const pid of [...new Set(shots.map((s) => s.projectId))]) {
revalidatePath(`/projects/${pid}`);
}
revalidatePath(`/shot-status`);
return { success: true, updated: shots.length, artistName };
}
// ── Bulk Manual Delivery ──────────────────────────────────────────────────────
/**
* Record that a selection of shots was delivered outside the render pipeline
* (by hand, before packages existed), or clear that record when
* `deliveredOn` is null. The delivery countdown counts these alongside
* DELIVERED EXR packages (lib/dashboard/ops.ts).
*
* `deliveredOn` is the day the frames went out ("yyyy-MM-dd"), stored at
* noon UTC so the calendar day survives any timezone it is shown in.
*/
export async function bulkSetManualDelivery(
shotIds: string[],
deliveredOn: string | null,
note?: string,
/** Where it was uploaded and who was sent the link. */
evidence?: { uploadUrl?: string; sharedWith?: string },
) {
const session = await auth();
if (!session?.user) throw new Error("Unauthorized");
if (!["ADMIN", "PRODUCER", "SUPERVISOR"].includes(session.user.role)) {
throw new Error("Insufficient permissions");
}
const ids = z.array(z.string().cuid()).parse(shotIds);
if (!ids.length) return { success: true as const, updated: 0 };
let deliveredAt: Date | null = null;
if (deliveredOn) {
const day = z.string().regex(/^\d{4}-\d{2}-\d{2}$/).parse(deliveredOn);
deliveredAt = new Date(`${day}T12:00:00.000Z`);
if (Number.isNaN(deliveredAt.getTime())) throw new Error("Invalid delivery date");
if (deliveredAt.getTime() > Date.now() + 24 * 60 * 60 * 1000) {
throw new Error("A delivery date can't be in the future");
}
}
const shots = await db.shot.findMany({
where: { id: { in: ids } },
select: { id: true, projectId: true },
});
if (shots.length !== ids.length) throw new Error("Some shots not found");
const trimmedNote = note?.trim() || null;
const uploadUrl = evidence?.uploadUrl?.trim() || null;
const sharedWith = evidence?.sharedWith?.trim() || null;
if (uploadUrl && !/^https?:\/\/\S+$/i.test(uploadUrl)) {
return { success: false as const, error: "The upload link must be a full http(s) link" };
}
// A backfill of old deliveries may have no link to give. A shot a client is
// waiting on is different: without the link and recipient the request it
// answers would stay open, so say so now rather than leave it unexplained.
if (deliveredAt && (!uploadUrl || !sharedWith)) {
const owed = await countShotsOnOpenRequests(ids);
if (owed > 0) {
// Returned, not thrown: a production build replaces a thrown action
// error with a generic message, and this one has to reach the person.
return {
success: false as const,
error: `${owed} of these shots ${owed === 1 ? "is" : "are"} on an open delivery request — add the upload link and who it was sent to`,
};
}
}
await db.shot.updateMany({
where: { id: { in: ids } },
data: deliveredAt
? {
manualDeliveredAt: deliveredAt,
manualDeliveredById: session.user.id,
manualDeliveryNote: trimmedNote,
manualDeliveryUrl: uploadUrl,
manualDeliverySharedWith: sharedWith,
}
: {
manualDeliveredAt: null,
manualDeliveredById: null,
manualDeliveryNote: null,
manualDeliveryUrl: null,
manualDeliverySharedWith: null,
},
});
for (const pid of [...new Set(shots.map((s) => s.projectId))]) {
revalidatePath(`/projects/${pid}`);
}
revalidatePath(`/shot-status`);
revalidatePath(`/dashboard`);
return { success: true as const, updated: shots.length };
}
// ── Bulk Delete Shots ─────────────────────────────────────────────────────────
export async function bulkDeleteShots(shotIds: string[]) {
const session = await auth();
if (!session?.user) throw new Error("Unauthorized");
if (!["ADMIN", "PRODUCER", "SUPERVISOR"].includes(session.user.role)) {
throw new Error("Insufficient permissions");
}
if (!shotIds.length) return { success: true, deleted: 0, failed: [] as { shotId: string; shotCode: string; reason: string }[] };
const shots = await db.shot.findMany({
where: { id: { in: shotIds } },
select: { id: true, shotCode: true, projectId: true },
});
const projectIds = [...new Set(shots.map((s) => s.projectId))];
const failed: { shotId: string; shotCode: string; reason: string }[] = [];
let deleted = 0;
// One at a time, not deleteMany: a shot with renders or deliveries is
// protected at the database level (exports_shotId_fkey is ON DELETE
// RESTRICT, deliberately — delivery history must never be destroyable by
// deleting the shot underneath it). A single bulk statement would abort
// entirely on the first shot it hits; deleting individually means every
// shot that *can* go still does, and the ones that can't are reported by
// name instead of failing the whole selection.
for (const shot of shots) {
try {
await db.shot.delete({ where: { id: shot.id } });
deleted += 1;
} catch (e) {
failed.push({
shotId: shot.id,
shotCode: shot.shotCode,
reason:
e instanceof Prisma.PrismaClientKnownRequestError && e.code === "P2003"
? "has renders or deliveries — delete those first"
: e instanceof Error
? e.message
: "unknown error",
});
}
}
for (const pid of projectIds) {
revalidatePath(`/projects/${pid}`);
}
revalidatePath(`/shot-status`);
return { success: true, deleted, failed };
}
export async function renameFootagePlate(plateId: string, label: string) { export async function renameFootagePlate(plateId: string, label: string) {
const session = await auth(); const session = await auth();
if (!session?.user) throw new Error("Unauthorized"); if (!session?.user) throw new Error("Unauthorized");
@@ -654,14 +891,20 @@ export async function internallyApproveShot(shotId: string) {
}); });
if (!shot) throw new Error("Shot not found"); if (!shot) throw new Error("Shot not found");
await db.shot.update({ // Set the approval inputs and let the derivation pick the status. Writing
// READY_FOR_CLIENT directly skipped the rule that an outstanding CHANGES task
// outranks any approval, so a shot could be pushed past open rework and then
// snap back to REVISIONS on the next unrelated recalc.
await db.$transaction(async (tx) => {
await tx.shot.update({
where: { id: shotId }, where: { id: shotId },
data: { data: {
shotApprovalStatus: "INTERNALLY_APPROVED", shotApprovalStatus: "INTERNALLY_APPROVED",
sharedWithClient: false, sharedWithClient: false,
status: "READY_FOR_CLIENT",
}, },
}); });
await recalcShotStatus(shotId, tx);
});
revalidatePath(`/projects/${shot.projectId}`); revalidatePath(`/projects/${shot.projectId}`);
revalidatePath(`/projects/${shot.projectId}/shots/${shotId}`); revalidatePath(`/projects/${shot.projectId}/shots/${shotId}`);
@@ -703,7 +946,7 @@ export async function shareWithClient(shotId: string) {
// Mark shot as shared // Mark shot as shared
await tx.shot.update({ await tx.shot.update({
where: { id: shotId }, where: { id: shotId },
data: { sharedWithClient: true, status: "CLIENT_REVIEW" }, data: { sharedWithClient: true },
}); });
// For each task, make the latest version client-visible // For each task, make the latest version client-visible
@@ -723,6 +966,8 @@ export async function shareWithClient(shotId: string) {
}); });
} }
} }
await recalcShotStatus(shotId, tx);
}); });
revalidatePath(`/projects/${shot.projectId}`); revalidatePath(`/projects/${shot.projectId}`);
@@ -755,7 +1000,7 @@ export async function unshareFromClient(shotId: string) {
await db.$transaction(async (tx) => { await db.$transaction(async (tx) => {
await tx.shot.update({ await tx.shot.update({
where: { id: shotId }, where: { id: shotId },
data: { sharedWithClient: false, status: "READY_FOR_CLIENT" }, data: { sharedWithClient: false },
}); });
// Hide all client-visible versions on this shot's tasks // Hide all client-visible versions on this shot's tasks
@@ -766,6 +1011,8 @@ export async function unshareFromClient(shotId: string) {
data: { isClientVisible: false }, data: { isClientVisible: false },
}); });
} }
await recalcShotStatus(shotId, tx);
}); });
revalidatePath(`/projects/${shot.projectId}`); revalidatePath(`/projects/${shot.projectId}`);
@@ -794,9 +1041,12 @@ export async function clientApproveShot(shotId: string) {
if (!shot) throw new Error("Shot not found"); if (!shot) throw new Error("Shot not found");
if (!shot.sharedWithClient) throw new Error("Shot is not shared with client"); if (!shot.sharedWithClient) throw new Error("Shot is not shared with client");
await db.shot.update({ await db.$transaction(async (tx) => {
await tx.shot.update({
where: { id: shotId }, where: { id: shotId },
data: { shotApprovalStatus: "CLIENT_APPROVED", status: "COMPLETE" }, data: { shotApprovalStatus: "CLIENT_APPROVED" },
});
await recalcShotStatus(shotId, tx);
}); });
revalidatePath(`/projects/${shot.projectId}`); revalidatePath(`/projects/${shot.projectId}`);
@@ -826,14 +1076,15 @@ export async function unapproveShot(shotId: string) {
throw new Error("Shot is not client-approved"); throw new Error("Shot is not client-approved");
} }
const newStatus = shot.sharedWithClient ? "CLIENT_REVIEW" : "READY_FOR_CLIENT"; // The derivation already encodes "CLIENT_REVIEW if still shared, else
// READY_FOR_CLIENT" for an INTERNALLY_APPROVED shot, and additionally honours
await db.shot.update({ // any open CHANGES task.
await db.$transaction(async (tx) => {
await tx.shot.update({
where: { id: shotId }, where: { id: shotId },
data: { data: { shotApprovalStatus: "INTERNALLY_APPROVED" },
shotApprovalStatus: "INTERNALLY_APPROVED", });
status: newStatus, await recalcShotStatus(shotId, tx);
},
}); });
revalidatePath(`/projects/${shot.projectId}`); revalidatePath(`/projects/${shot.projectId}`);
@@ -1134,9 +1385,12 @@ export async function assignShotGroups(
} }
/** /**
* Internal: handle client requesting changes on a shot. * Session-authenticated wrapper for requesting changes on a shot — a supervisor
* Resets shotApprovalStatus = PENDING, sharedWithClient = false. * or producer relaying a client note from inside the app.
* Recalculates shot status (will become REVISIONS if tasks set to CHANGES). *
* The client portal cannot use this: it runs on a review token, not a session,
* so it calls markShotForRevisions directly from its route. Both go through that
* one helper so the two entry points cannot drift apart again.
*/ */
export async function clientRequestShotChanges(shotId: string, taskId?: string) { export async function clientRequestShotChanges(shotId: string, taskId?: string) {
const session = await auth(); const session = await auth();
@@ -1151,28 +1405,7 @@ export async function clientRequestShotChanges(shotId: string, taskId?: string)
}); });
if (!shot) throw new Error("Shot not found"); if (!shot) throw new Error("Shot not found");
await db.$transaction(async (tx) => { await db.$transaction((tx) => markShotForRevisions(tx, shotId, taskId));
// Reset shot approval
await tx.shot.update({
where: { id: shotId },
data: { shotApprovalStatus: "PENDING", sharedWithClient: false },
});
// If a specific task is called out, mark it CHANGES; otherwise mark all non-DONE tasks
if (taskId) {
await tx.task.update({
where: { id: taskId },
data: { status: "CHANGES" },
});
} else {
await tx.task.updateMany({
where: { shotId, status: { not: "DONE" } },
data: { status: "CHANGES" },
});
}
await recalcShotStatus(shotId, tx);
});
revalidatePath(`/projects/${shot.projectId}`); revalidatePath(`/projects/${shot.projectId}`);
revalidatePath(`/projects/${shot.projectId}/shots/${shotId}`); revalidatePath(`/projects/${shot.projectId}/shots/${shotId}`);
@@ -1211,3 +1444,91 @@ export async function updateShotVersion(shotId: string, version: string) {
revalidatePath(`/projects/${shot.projectId}/shots/${shotId}`); revalidatePath(`/projects/${shot.projectId}/shots/${shotId}`);
return { success: true, shotVersion: version }; return { success: true, shotVersion: version };
} }
// ── Generated (render-derived) shot thumbnails ───────────────────────────────
//
// A shot can carry two stills: `thumbnailUrl`, the reference frame that came
// with the brief, and `generatedThumbnailUrl`, a frame promoted from a render
// export. The reference always wins on display (lib/shot-thumbnail.ts), so
// these actions can only ever fill a gap — a promotion never overwrites the
// brief, and clearing one always falls back to it.
//
// Shows with `pipelineConfig.autoShotThumbnail` promote on every finished
// export automatically (lib/render-pipeline/preview.ts). These actions are the
// manual equivalent, and work regardless of that flag: a supervisor can pull a
// frame onto one shot on a project that is otherwise hands-off.
/**
* Promote a render export's thumbnail onto its shot.
*
* With no `exportId`, uses the newest export of that shot which actually has a
* thumbnail — "use the latest render frame".
*/
export async function promoteExportThumbnail(shotId: string, exportId?: string) {
const session = await auth();
if (!session?.user) throw new Error("Unauthorized");
if (!["ADMIN", "PRODUCER", "SUPERVISOR"].includes(session.user.role)) {
throw new Error("Insufficient permissions");
}
const shot = await db.shot.findUnique({
where: { id: shotId },
select: { id: true, projectId: true },
});
if (!shot) throw new Error("Shot not found");
const exportRow = await db.export.findFirst({
where: {
shotId,
thumbnailKey: { not: null },
...(exportId ? { id: exportId } : {}),
},
orderBy: { versionNumber: "desc" },
select: { id: true, thumbnailKey: true, versionString: true },
});
if (!exportRow?.thumbnailKey) {
throw new Error(
exportId
? "That export has no thumbnail — its preview may have been skipped, or the worker had no ffmpeg configured"
: "No render of this shot has produced a thumbnail yet"
);
}
const generatedThumbnailUrl = `/api/files/${exportRow.thumbnailKey}`;
await db.shot.update({
where: { id: shotId },
data: { generatedThumbnailUrl, generatedThumbnailFrom: exportRow.versionString },
});
revalidatePath(`/projects/${shot.projectId}`);
revalidatePath(`/projects/${shot.projectId}/shots/${shotId}`);
return {
success: true,
generatedThumbnailUrl,
generatedThumbnailFrom: exportRow.versionString,
};
}
/** Drop the render-derived still. The reference frame, if any, comes back. */
export async function clearGeneratedThumbnail(shotId: string) {
const session = await auth();
if (!session?.user) throw new Error("Unauthorized");
if (!["ADMIN", "PRODUCER", "SUPERVISOR"].includes(session.user.role)) {
throw new Error("Insufficient permissions");
}
const shot = await db.shot.findUnique({
where: { id: shotId },
select: { id: true, projectId: true },
});
if (!shot) throw new Error("Shot not found");
await db.shot.update({
where: { id: shotId },
data: { generatedThumbnailUrl: null, generatedThumbnailFrom: null },
});
revalidatePath(`/projects/${shot.projectId}`);
revalidatePath(`/projects/${shot.projectId}/shots/${shotId}`);
return { success: true };
}
+47 -3
View File
@@ -4,9 +4,10 @@ import { auth } from "@/auth";
import { db } from "@/lib/db"; import { db } from "@/lib/db";
import { revalidatePath } from "next/cache"; import { revalidatePath } from "next/cache";
import { z } from "zod"; import { z } from "zod";
import { recalcShotStatus } from "@/lib/shot-status"; import { recalcShotStatus, clearStaleShotApproval } from "@/lib/shot-status";
import { notifyNewVersionUploaded } from "@/lib/notifications"; import { notifyNewVersionUploaded } from "@/lib/notifications";
import { slackNotifyVersionUploaded } from "@/lib/slack"; import { slackNotifyVersionUploaded } from "@/lib/slack";
import { deleteStorageKeys, highResStorageKeys } from "@/lib/render-pipeline/high-res";
const createVersionSchema = z.object({ const createVersionSchema = z.object({
taskId: z.string().cuid(), taskId: z.string().cuid(),
@@ -50,9 +51,16 @@ export async function createVersion(data: z.infer<typeof createVersionSchema>) {
data: { status: "INTERNAL_REVIEW" }, data: { status: "INTERNAL_REVIEW" },
}); });
// Recalculate shot status // Recalculate shot status — clearing any stale sign-off first, so a new
// version does not land under a shot still reading COMPLETE.
if (task.shot) { if (task.shot) {
await recalcShotStatus(task.shot.id).catch(() => {}); const shotId = task.shot.id;
await db
.$transaction(async (tx) => {
await clearStaleShotApproval(tx, shotId);
await recalcShotStatus(shotId, tx);
})
.catch(() => {});
} }
// Get the next version number for this task // Get the next version number for this task
@@ -178,6 +186,8 @@ export async function deleteVersion(versionId: string) {
id: true, id: true,
isLatest: true, isLatest: true,
taskId: true, taskId: true,
hqFileUrl: true,
highResKey: true,
task: { select: { projectId: true, shotId: true } }, task: { select: { projectId: true, shotId: true } },
}, },
}); });
@@ -196,6 +206,8 @@ export async function deleteVersion(versionId: string) {
} }
await db.version.delete({ where: { id: versionId } }); await db.version.delete({ where: { id: versionId } });
// Its High quality MP4 and ProRes are large and referenced by nothing else.
await deleteStorageKeys(highResStorageKeys(version));
const projectId = version.task?.projectId; const projectId = version.task?.projectId;
const shotId = version.task?.shotId; const shotId = version.task?.shotId;
@@ -252,3 +264,35 @@ export async function getVersionComments(versionId: string) {
orderBy: { frameNumber: "asc" }, orderBy: { frameNumber: "asc" },
}); });
} }
const updateVersionHandlesSchema = z.object({
versionId: z.string().cuid(),
/** 0/0 = no handles (every frame is in the edit). */
handleHead: z.number().int().min(0).max(1000),
handleTail: z.number().int().min(0).max(1000),
/** Slate frames before the picture; null = infer from the media. */
pictureStartFrame: z.number().int().min(0).max(1000).nullable(),
});
/**
* Marks which frames of a version are handles (past the cut at each end), so
* the review player can flag them. Review metadata only — the media and any
* delivered files are untouched. Staff only: a client can't redefine the cut.
*/
export async function updateVersionHandles(data: z.infer<typeof updateVersionHandlesSchema>) {
const session = await auth();
if (!session?.user) throw new Error("Unauthorized");
if (session.user.role === "CLIENT") throw new Error("Forbidden");
const parsed = updateVersionHandlesSchema.parse(data);
const none = parsed.handleHead === 0 && parsed.handleTail === 0;
await db.version.update({
where: { id: parsed.versionId },
data: {
handleHead: none ? null : parsed.handleHead,
handleTail: none ? null : parsed.handleTail,
pictureStartFrame: parsed.pictureStartFrame,
},
});
revalidatePath(`/review/${parsed.versionId}`);
}
+689
View File
@@ -0,0 +1,689 @@
"use client";
import { useEffect, useRef, useState, useTransition } from "react";
import { useRouter } from "next/navigation";
import Link from "next/link";
import { differenceInCalendarDays, format, formatDistanceToNowStrict } from "date-fns";
import {
AlertTriangle,
Check,
ChevronDown,
ChevronRight,
Clock,
Flag,
Link2,
MessageSquareText,
Pencil,
Plus,
Trash2,
X,
} from "lucide-react";
import { Button } from "@/components/ui/button";
import { Avatar, AvatarFallback, AvatarImage } from "@/components/ui/avatar";
import { useToast } from "@/components/ui/use-toast";
import { cn, getInitials } from "@/lib/utils";
import {
addBoardItems,
addMilestone,
deleteBoardItem,
deleteMilestone,
setBoardItemDone,
setMilestoneDone,
setProjectBoardStatus,
updateBoardItem,
} from "@/actions/board";
import { FeedbackPasteDialog } from "./FeedbackPasteDialog";
type User = { id: string; name: string | null; email: string; image: string | null };
type BoardItem = {
id: string;
text: string;
code: string | null;
group: string;
waitingOn: string | null;
round: { id: string; title: string; dueAt: string | null } | null;
/** The player comment a pasted-feedback line was saved as */
comment: { versionId: string; frame: number } | null;
doneAt: string | null;
assignee: { id: string; name: string | null; image: string | null } | null;
shot: {
id: string;
shotCode: string;
status: string;
latest: { id: string; versionNumber: number; approvalStatus: string; isClientVisible: boolean } | null;
} | null;
relinkTo: string | null;
relinkIsExact: boolean;
};
export type BoardProject = {
id: string;
name: string;
code: string;
status: string;
boardStatus: string | null;
boardStatusAt: string | null;
shotTotal: number;
shotComplete: number;
milestones: { id: string; label: string; date: string; doneAt: string | null }[];
items: BoardItem[];
};
const SHOT_STATUS: Record<string, { label: string; color: string }> = {
WAITING: { label: "Waiting", color: "bg-zinc-500/10 text-zinc-400 border-zinc-500/20" },
IN_PROGRESS: { label: "In Progress", color: "bg-blue-500/10 text-blue-400 border-blue-500/20" },
INTERNAL_REVIEW: { label: "Internal Review", color: "bg-purple-500/10 text-purple-400 border-purple-500/20" },
READY_FOR_CLIENT: { label: "Ready for Client", color: "bg-cyan-500/10 text-cyan-400 border-cyan-500/20" },
CLIENT_REVIEW: { label: "Client Review", color: "bg-indigo-500/10 text-indigo-400 border-indigo-500/20" },
REVISIONS: { label: "Revisions", color: "bg-orange-500/10 text-orange-400 border-orange-500/20" },
COMPLETE: { label: "Complete", color: "bg-green-500/10 text-green-400 border-green-500/20" },
};
const APPROVAL: Record<string, { label: string; color: string }> = {
PENDING_REVIEW: { label: "pending", color: "text-zinc-500" },
APPROVED: { label: "approved", color: "text-green-400" },
REJECTED: { label: "rejected", color: "text-red-400" },
NEEDS_CHANGES: { label: "changes", color: "text-orange-400" },
};
export function BoardClient({
projects,
users,
who,
}: {
projects: BoardProject[];
users: User[];
who: string | null;
}) {
const router = useRouter();
const filters = [
{ key: null, label: "Everyone" },
...users.map((u) => ({ key: u.id, label: u.name?.split(" ")[0] ?? u.email })),
{ key: "none", label: "Unassigned" },
];
return (
<div className="p-4 md:p-8 max-w-5xl">
<div className="mb-6 flex flex-wrap items-end justify-between gap-4">
<div>
<h1 className="text-3xl font-bold text-white">Board</h1>
<p className="text-zinc-400 mt-1">{format(new Date(), "EEEE, d MMMM yyyy")}</p>
</div>
<div className="flex flex-wrap gap-1 rounded-lg border border-zinc-800 bg-zinc-900 p-1">
{filters.map((f) => (
<button
key={f.key ?? "all"}
type="button"
onClick={() => router.push(f.key ? `/board?who=${f.key}` : "/board")}
className={cn(
"rounded-md px-3 py-1 text-xs font-medium transition-colors",
who === f.key ? "bg-amber-500/10 text-amber-400" : "text-zinc-400 hover:text-white",
)}
>
{f.label}
</button>
))}
</div>
</div>
{projects.length === 0 && (
<p className="text-sm text-zinc-500">No active or on-hold projects.</p>
)}
<div className="space-y-6">
{projects.map((p) => (
<ProjectSection key={p.id} project={p} users={users} who={who} />
))}
</div>
</div>
);
}
function ProjectSection({ project, users, who }: { project: BoardProject; users: User[]; who: string | null }) {
const [showDone, setShowDone] = useState(false);
const [pasting, setPasting] = useState(false);
const visible = project.items.filter((i) =>
who === null ? true : who === "none" ? !i.assignee : i.assignee?.id === who,
);
const open = visible.filter((i) => !i.doneAt);
const done = visible.filter((i) => i.doneAt);
// Pasted feedback stays together under its round, flags and all
const rounds: { round: NonNullable<BoardItem["round"]>; items: BoardItem[] }[] = [];
for (const item of open) {
if (!item.round) continue;
let r = rounds.find((x) => x.round.id === item.round!.id);
if (!r) rounds.push((r = { round: item.round, items: [] }));
r.items.push(item);
}
rounds.sort((a, b) => (a.round.dueAt ?? "9").localeCompare(b.round.dueAt ?? "9"));
const loose = open.filter((i) => !i.round);
const flagged = loose.filter((i) => i.code && !i.shot);
const waiting = loose.filter((i) => i.waitingOn && !(i.code && !i.shot));
const rest = loose.filter((i) => !flagged.includes(i) && !waiting.includes(i));
// Groups keep the order they were first typed in
const groups: { name: string; items: BoardItem[] }[] = [];
for (const item of rest) {
let g = groups.find((x) => x.name === item.group);
if (!g) groups.push((g = { name: item.group, items: [] }));
g.items.push(item);
}
groups.sort((a, b) => (a.name === "" ? -1 : b.name === "" ? 1 : 0));
const pct = project.shotTotal ? Math.round((project.shotComplete / project.shotTotal) * 100) : 0;
return (
<section className="rounded-xl border border-zinc-800 bg-zinc-900">
<header className="flex flex-wrap items-center gap-x-3 gap-y-1 border-b border-zinc-800 px-4 py-3">
<Link href={`/projects/${project.id}`} className="text-lg font-semibold text-white hover:text-amber-400">
{project.name}
</Link>
<span className="text-xs text-zinc-500">{project.code}</span>
{project.status === "ON_HOLD" && (
<span className="rounded border border-yellow-500/20 bg-yellow-500/10 px-1.5 py-0.5 text-[10px] font-medium text-yellow-400">
On hold
</span>
)}
<Button
size="sm"
variant="outline"
className="ml-auto h-7"
onClick={() => setPasting(true)}
title="Paste a client's feedback message"
>
<MessageSquareText /> Paste feedback
</Button>
{project.shotTotal > 0 && (
<div className="flex items-center gap-2 text-xs text-zinc-400">
<div className="h-1.5 w-24 overflow-hidden rounded-full bg-zinc-800">
<div className="h-full bg-green-500/70" style={{ width: `${pct}%` }} />
</div>
{project.shotComplete}/{project.shotTotal} shots complete
</div>
)}
</header>
<div className="space-y-4 px-4 py-3">
<StatusLine project={project} />
<Milestones project={project} />
{rounds.map(({ round, items }) => (
<RoundBlock key={round.id} round={round} count={items.length}>
{items.map((i) => <ItemRow key={i.id} item={i} users={users} projectId={project.id} />)}
</RoundBlock>
))}
{flagged.length > 0 && (
<ItemBlock title="Flags" icon={<Flag className="h-3.5 w-3.5 text-red-400" />}>
{flagged.map((i) => <ItemRow key={i.id} item={i} users={users} projectId={project.id} />)}
</ItemBlock>
)}
{waiting.length > 0 && (
<ItemBlock title="Waiting on" icon={<Clock className="h-3.5 w-3.5 text-amber-400" />}>
{waiting.map((i) => <ItemRow key={i.id} item={i} users={users} projectId={project.id} />)}
</ItemBlock>
)}
{groups.map((g) => (
<ItemBlock key={g.name || "_"} title={g.name}>
{g.items.map((i) => <ItemRow key={i.id} item={i} users={users} projectId={project.id} />)}
</ItemBlock>
))}
<QuickAdd projectId={project.id} />
{done.length > 0 && (
<div>
<button
type="button"
onClick={() => setShowDone(!showDone)}
className="flex items-center gap-1 text-xs text-zinc-500 hover:text-zinc-300"
>
{showDone ? <ChevronDown className="h-3.5 w-3.5" /> : <ChevronRight className="h-3.5 w-3.5" />}
Done this week ({done.length})
</button>
{showDone && (
<div className="mt-1">
{done.map((i) => <ItemRow key={i.id} item={i} users={users} projectId={project.id} />)}
</div>
)}
</div>
)}
</div>
<FeedbackPasteDialog
projectId={project.id}
projectName={project.name}
open={pasting}
onOpenChange={setPasting}
/>
</section>
);
}
function RoundBlock({
round,
count,
children,
}: {
round: NonNullable<BoardItem["round"]>;
count: number;
children: React.ReactNode;
}) {
const due = round.dueAt ? new Date(round.dueAt) : null;
const late = due && due.getTime() < Date.now();
const days = due ? differenceInCalendarDays(due, new Date()) : null;
const when = due
? days === 0 ? `today ${format(due, "HH:mm")}` : days === 1 ? `tomorrow ${format(due, "HH:mm")}` : format(due, "d MMM HH:mm")
: null;
return (
<div>
<div className="mb-1 flex flex-wrap items-center gap-1.5 text-xs uppercase tracking-wider text-zinc-500">
<MessageSquareText className="h-3.5 w-3.5 text-indigo-400" />
{round.title}
{when && (
<span
className={cn(
"rounded px-1.5 py-px normal-case tracking-normal",
late ? "bg-red-500/10 text-red-300" : days !== null && days <= 1 ? "bg-amber-500/10 text-amber-300" : "text-zinc-400",
)}
>
{late ? "overdue · " : "due "}{when}
</span>
)}
<span className="normal-case tracking-normal text-zinc-600">{count} open</span>
</div>
<div className="divide-y divide-zinc-800/60">{children}</div>
</div>
);
}
function ItemBlock({ title, icon, children }: { title: string; icon?: React.ReactNode; children: React.ReactNode }) {
return (
<div>
{title && (
<div className="mb-1 flex items-center gap-1.5 text-xs uppercase tracking-wider text-zinc-500">
{icon}
{title}
</div>
)}
<div className="divide-y divide-zinc-800/60">{children}</div>
</div>
);
}
function useAction() {
const router = useRouter();
const { toast } = useToast();
const [isPending, startTransition] = useTransition();
const run = (fn: () => Promise<unknown>, after?: () => void) =>
startTransition(async () => {
try {
await fn();
after?.();
router.refresh();
} catch (e) {
toast({ title: "Couldn't save", description: (e as Error).message, variant: "destructive" });
}
});
return { run, isPending };
}
// ── Status line ──────────────────────────────────────────────────────────────
function StatusLine({ project }: { project: BoardProject }) {
const [editing, setEditing] = useState(false);
const [value, setValue] = useState(project.boardStatus ?? "");
const { run, isPending } = useAction();
const save = () =>
run(() => setProjectBoardStatus({ projectId: project.id, status: value }), () => setEditing(false));
if (editing) {
return (
<div className="space-y-1.5">
<textarea
autoFocus
value={value}
onChange={(e) => setValue(e.target.value)}
onKeyDown={(e) => {
if (e.key === "Enter" && !e.shiftKey) { e.preventDefault(); save(); }
if (e.key === "Escape") { setValue(project.boardStatus ?? ""); setEditing(false); }
}}
rows={2}
placeholder="Where things stand — e.g. Awaiting feedback on pick-ups"
className="w-full resize-y rounded-lg border border-zinc-700 bg-zinc-950 px-3 py-2 text-sm text-white placeholder:text-zinc-600 focus:border-amber-500/50 focus:outline-none"
/>
<div className="flex gap-2">
<Button size="sm" onClick={save} disabled={isPending}>Save</Button>
<Button size="sm" variant="ghost" onClick={() => { setValue(project.boardStatus ?? ""); setEditing(false); }}>
Cancel
</Button>
</div>
</div>
);
}
return (
<button
type="button"
onClick={() => setEditing(true)}
className="group block w-full text-left"
>
{project.boardStatus ? (
<p className="whitespace-pre-wrap text-sm text-zinc-200">
{project.boardStatus}
{project.boardStatusAt && (
<span className="ml-2 text-xs text-zinc-600">
{formatDistanceToNowStrict(new Date(project.boardStatusAt), { addSuffix: true })}
</span>
)}
<Pencil className="ml-2 inline h-3 w-3 text-zinc-600 opacity-0 group-hover:opacity-100" />
</p>
) : (
<p className="text-sm text-zinc-600 group-hover:text-zinc-400">+ Add a status line</p>
)}
</button>
);
}
// ── Milestones ───────────────────────────────────────────────────────────────
function Milestones({ project }: { project: BoardProject }) {
const [adding, setAdding] = useState(false);
const [label, setLabel] = useState("");
const [date, setDate] = useState("");
const { run, isPending } = useAction();
const add = () => {
if (!label.trim() || !date) return;
// Noon keeps the calendar day stable across the studio/server time zones
run(() => addMilestone({ projectId: project.id, label, date: `${date}T12:00:00` }), () => {
setLabel("");
setDate("");
setAdding(false);
});
};
return (
<div className="flex flex-wrap items-center gap-1.5">
{project.milestones.map((m) => <MilestoneChip key={m.id} m={m} />)}
{adding ? (
<div className="flex flex-wrap items-center gap-1.5">
<input
autoFocus
value={label}
onChange={(e) => setLabel(e.target.value)}
onKeyDown={(e) => e.key === "Enter" && add()}
placeholder="e.g. Final delivery"
className="h-7 w-40 rounded-md border border-zinc-700 bg-zinc-950 px-2 text-xs text-white placeholder:text-zinc-600 focus:outline-none"
/>
<input
type="date"
value={date}
onChange={(e) => setDate(e.target.value)}
onKeyDown={(e) => e.key === "Enter" && add()}
className="h-7 rounded-md border border-zinc-700 bg-zinc-950 px-2 text-xs text-white [color-scheme:dark] focus:outline-none"
/>
<Button size="sm" className="h-7" onClick={add} disabled={isPending || !label.trim() || !date}>Add</Button>
<Button size="sm" variant="ghost" className="h-7" onClick={() => setAdding(false)}>Cancel</Button>
</div>
) : (
<button
type="button"
onClick={() => setAdding(true)}
className="flex h-7 items-center gap-1 rounded-md px-2 text-xs text-zinc-600 hover:bg-zinc-800 hover:text-zinc-300"
>
<Plus className="h-3 w-3" /> Date
</button>
)}
</div>
);
}
function MilestoneChip({ m }: { m: BoardProject["milestones"][number] }) {
const { run } = useAction();
const days = differenceInCalendarDays(new Date(m.date), new Date());
const done = !!m.doneAt;
const late = !done && days < 0;
const soon = !done && days >= 0 && days <= 7;
const when = done ? "done" : days === 0 ? "today" : days === 1 ? "tomorrow" : days > 0 ? `in ${days}d` : `${-days}d late`;
return (
<div
className={cn(
"group flex h-7 items-center gap-1.5 rounded-md border px-2 text-xs",
done ? "border-zinc-800 text-zinc-600" :
late ? "border-red-500/30 bg-red-500/10 text-red-300" :
soon ? "border-amber-500/30 bg-amber-500/10 text-amber-300" :
"border-zinc-700 text-zinc-300",
)}
>
<button
type="button"
title={done ? "Mark not done" : "Mark done"}
onClick={() => run(() => setMilestoneDone(m.id, !done))}
className={cn(
"flex h-3.5 w-3.5 items-center justify-center rounded-sm border",
done ? "border-green-500/50 bg-green-500/20 text-green-400" : "border-current opacity-60 hover:opacity-100",
)}
>
{done && <Check className="h-2.5 w-2.5" />}
</button>
<span className={cn(done && "line-through")}>{m.label}</span>
<span className="opacity-70">{format(new Date(m.date), "d MMM")}</span>
<span className="font-medium">· {when}</span>
<button
type="button"
title="Remove"
onClick={() => { if (confirm(`Remove "${m.label}"?`)) run(() => deleteMilestone(m.id)); }}
className="hidden text-zinc-500 hover:text-red-400 group-hover:block"
>
<X className="h-3 w-3" />
</button>
</div>
);
}
// ── Items ────────────────────────────────────────────────────────────────────
function ItemRow({ item, users, projectId }: { item: BoardItem; users: User[]; projectId: string }) {
const [editing, setEditing] = useState(false);
const { run, isPending } = useAction();
const done = !!item.doneAt;
const flagged = !!item.code && !item.shot;
if (editing) return <ItemEditor item={item} users={users} onClose={() => setEditing(false)} />;
const st = item.shot ? SHOT_STATUS[item.shot.status] : null;
const v = item.shot?.latest;
return (
<div className={cn("group flex items-start gap-2.5 py-1.5", isPending && "opacity-50")}>
<button
type="button"
title={done ? "Mark not done" : "Mark done"}
onClick={() => run(() => setBoardItemDone(item.id, !done))}
className={cn(
"mt-0.5 flex h-4 w-4 shrink-0 items-center justify-center rounded border",
done ? "border-green-500/50 bg-green-500/20 text-green-400" : "border-zinc-600 hover:border-zinc-400",
)}
>
{done && <Check className="h-3 w-3" />}
</button>
<div className="min-w-0 flex-1">
<div className="flex flex-wrap items-center gap-x-2 gap-y-1 text-sm">
{item.shot && (
<Link
href={`/projects/${projectId}/shots/${item.shot.id}`}
className="font-mono text-xs text-amber-400 hover:underline"
>
{item.shot.shotCode}
</Link>
)}
{flagged && (
<span className="flex items-center gap-1 font-mono text-xs text-red-400" title="Not a shot in this project">
<AlertTriangle className="h-3 w-3" />
{item.code}
</span>
)}
{st && !done && (
<span className={cn("rounded border px-1.5 py-px text-[10px] font-medium", st.color)}>{st.label}</span>
)}
{v && !done && (
<Link href={`/review/${v.id}`} className="text-[11px] text-zinc-500 hover:text-zinc-300">
v{String(v.versionNumber).padStart(3, "0")}{" "}
<span className={APPROVAL[v.approvalStatus]?.color}>{APPROVAL[v.approvalStatus]?.label}</span>
{v.isClientVisible && <span className="text-indigo-400"> · sent</span>}
</Link>
)}
<span className={cn("text-zinc-200", done && "text-zinc-600 line-through")}>{item.text}</span>
{item.comment && (
<Link
href={`/review/${item.comment.versionId}`}
className="text-[11px] text-indigo-400/80 hover:text-indigo-300"
title="Open the note in the player"
>
note @ F{item.comment.frame}
</Link>
)}
</div>
{(item.waitingOn || (flagged && !done)) && (
<div className="mt-1 flex flex-wrap items-center gap-2 text-xs">
{item.waitingOn && (
<span className="flex items-center gap-1 rounded bg-amber-500/10 px-1.5 py-0.5 text-amber-300">
<Clock className="h-3 w-3" /> Waiting on {item.waitingOn}
</span>
)}
{flagged && !done && (
item.relinkTo ? (
<button
type="button"
onClick={() => run(() => updateBoardItem(item.id, { code: item.relinkTo }))}
className="flex items-center gap-1 text-zinc-400 hover:text-amber-400"
>
<Link2 className="h-3 w-3" />
{item.relinkIsExact ? `${item.relinkTo} exists now. Link it` : `Did you mean ${item.relinkTo}?`}
</button>
) : (
<span className="text-zinc-500">Not a shot in this project</span>
)
)}
</div>
)}
</div>
{item.assignee && (
<span className="flex shrink-0 items-center gap-1.5 text-xs text-zinc-400" title={item.assignee.name ?? ""}>
<Avatar className="h-5 w-5">
{item.assignee.image && <AvatarImage src={item.assignee.image} />}
<AvatarFallback className="text-[9px]">{getInitials(item.assignee.name)}</AvatarFallback>
</Avatar>
<span className="hidden sm:inline">{item.assignee.name?.split(" ")[0]}</span>
</span>
)}
<div className="flex shrink-0 gap-0.5 opacity-100 md:opacity-0 md:group-hover:opacity-100">
<button type="button" title="Edit" onClick={() => setEditing(true)} className="rounded p-1 text-zinc-500 hover:bg-zinc-800 hover:text-white">
<Pencil className="h-3.5 w-3.5" />
</button>
<button
type="button"
title="Delete"
onClick={() => { if (confirm("Delete this line?")) run(() => deleteBoardItem(item.id)); }}
className="rounded p-1 text-zinc-500 hover:bg-zinc-800 hover:text-red-400"
>
<Trash2 className="h-3.5 w-3.5" />
</button>
</div>
</div>
);
}
function ItemEditor({ item, users, onClose }: { item: BoardItem; users: User[]; onClose: () => void }) {
const [code, setCode] = useState(item.shot?.shotCode ?? item.code ?? "");
const [text, setText] = useState(item.text);
const [assigneeId, setAssigneeId] = useState(item.assignee?.id ?? "");
const [waitingOn, setWaitingOn] = useState(item.waitingOn ?? "");
const [group, setGroup] = useState(item.group);
const { run, isPending } = useAction();
const save = () =>
run(
() => updateBoardItem(item.id, { code, text, assigneeId: assigneeId || null, waitingOn, group }),
onClose,
);
const field = "h-8 rounded-md border border-zinc-700 bg-zinc-950 px-2 text-xs text-white placeholder:text-zinc-600 focus:border-amber-500/50 focus:outline-none";
return (
<div
className="my-1 grid grid-cols-1 gap-2 rounded-lg border border-zinc-700 bg-zinc-950/50 p-2 sm:grid-cols-[10rem_1fr]"
onKeyDown={(e) => {
if (e.key === "Enter") { e.preventDefault(); save(); }
if (e.key === "Escape") onClose();
}}
>
<input value={code} onChange={(e) => setCode(e.target.value)} placeholder="Shot code" className={cn(field, "font-mono")} />
<input autoFocus value={text} onChange={(e) => setText(e.target.value)} placeholder="Note" className={field} />
<select value={assigneeId} onChange={(e) => setAssigneeId(e.target.value)} className={field}>
<option value="">Unassigned</option>
{users.map((u) => <option key={u.id} value={u.id}>{u.name ?? u.email}</option>)}
</select>
<input value={waitingOn} onChange={(e) => setWaitingOn(e.target.value)} placeholder="Waiting on (blank = not blocked)" className={field} />
<input value={group} onChange={(e) => setGroup(e.target.value)} placeholder="Heading (optional)" className={field} />
<div className="flex justify-end gap-2">
<Button size="sm" variant="ghost" onClick={onClose}>Cancel</Button>
<Button size="sm" onClick={save} disabled={isPending}>Save</Button>
</div>
</div>
);
}
function QuickAdd({ projectId }: { projectId: string }) {
const [value, setValue] = useState("");
const ref = useRef<HTMLTextAreaElement>(null);
const { toast } = useToast();
const { run, isPending } = useAction();
// Grow with pasted blocks
useEffect(() => {
const el = ref.current;
if (!el) return;
el.style.height = "auto";
el.style.height = `${Math.min(el.scrollHeight, 320)}px`;
}, [value]);
const submit = () => {
if (!value.trim()) return;
run(async () => {
const res = await addBoardItems({ projectId, input: value });
if (res.unmatched.length) {
toast({
title: `${res.unmatched.length} code${res.unmatched.length === 1 ? "" : "s"} not in this project`,
description: `${res.unmatched.join(", ")}: flagged on the board.`,
});
}
}, () => setValue(""));
};
return (
<div>
<textarea
ref={ref}
value={value}
onChange={(e) => setValue(e.target.value)}
onKeyDown={(e) => {
if (e.key === "Enter" && !e.shiftKey) { e.preventDefault(); submit(); }
}}
rows={1}
disabled={isPending}
placeholder="Add a line, e.g. SHOT_CODE finalise (Chris) wait: client GFX, or paste a list"
className="w-full resize-none rounded-lg border border-dashed border-zinc-700 bg-transparent px-3 py-2 text-sm text-white placeholder:text-zinc-600 focus:border-solid focus:border-amber-500/50 focus:outline-none"
/>
</div>
);
}
@@ -0,0 +1,342 @@
"use client";
import { useState, useTransition } from "react";
import { useRouter } from "next/navigation";
import { format } from "date-fns";
import { AlertTriangle, ArrowLeft, Link2, MessageSquareText } from "lucide-react";
import { Button } from "@/components/ui/button";
import { Dialog, DialogContent, DialogDescription, DialogHeader, DialogTitle } from "@/components/ui/dialog";
import { useToast } from "@/components/ui/use-toast";
import { cn } from "@/lib/utils";
import { parseDue } from "@/lib/feedback-parse";
import { commitFeedback, previewFeedback, type FeedbackPreview, type FeedbackPreviewNote } from "@/actions/feedback";
type NoteState = {
include: boolean;
text: string;
versionId: string | null;
/** Typed frame; null = use the selected version's converted frame */
frame: string | null;
setChanges: boolean;
};
type RoundState = { title: string; due: string; notes: Record<string, NoteState> };
const LOCAL_DT = "yyyy-MM-dd'T'HH:mm";
function initialState(preview: FeedbackPreview): RoundState[] {
return preview.rounds.map((r) => {
const due = parseDue(r.dueText);
return {
title: r.title || `Feedback ${format(new Date(), "d MMM")}`,
due: due ? format(due, LOCAL_DT) : "",
notes: Object.fromEntries(
r.notes.map((n) => [
n.key,
{ include: true, text: n.text, versionId: n.defaultVersionId, frame: null, setChanges: true },
]),
),
};
});
}
export function FeedbackPasteDialog({
projectId,
projectName,
open,
onOpenChange,
}: {
projectId: string;
projectName: string;
open: boolean;
onOpenChange: (open: boolean) => void;
}) {
const router = useRouter();
const { toast } = useToast();
const [input, setInput] = useState("");
const [preview, setPreview] = useState<FeedbackPreview | null>(null);
const [rounds, setRounds] = useState<RoundState[]>([]);
const [isPending, startTransition] = useTransition();
const reset = () => {
setInput("");
setPreview(null);
setRounds([]);
};
const read = (text: string) =>
startTransition(async () => {
try {
const p = await previewFeedback(projectId, text);
if (p.rounds.length === 0) {
toast({ title: "No shot notes found", description: "Each note needs to start with a shot code.", variant: "destructive" });
return;
}
setPreview(p);
setRounds(initialState(p));
} catch (e) {
toast({ title: "Couldn't read feedback", description: (e as Error).message, variant: "destructive" });
}
});
// Accepting a suggested code rewrites the paste and reads it again, so
// everything downstream (versions, frames) comes from the real shot.
const applySuggestion = (code: string, suggestion: string) => {
const next = input.split(code).join(suggestion);
setInput(next);
read(next);
};
const updateNote = (ri: number, key: string, patch: Partial<NoteState>) =>
setRounds((rs) => rs.map((r, i) => (i === ri ? { ...r, notes: { ...r.notes, [key]: { ...r.notes[key], ...patch } } } : r)));
const frameFor = (n: FeedbackPreviewNote, s: NoteState): number | null => {
if (s.frame !== null) return s.frame.trim() === "" ? null : Number(s.frame);
return n.versions.find((v) => v.id === s.versionId)?.playerFrame ?? null;
};
const included = preview
? preview.rounds.flatMap((r, ri) => r.notes.filter((n) => rounds[ri]?.notes[n.key]?.include && rounds[ri].notes[n.key].text.trim()))
: [];
const save = () => {
if (!preview) return;
const payload = preview.rounds
.map((r, ri) => {
const rs = rounds[ri];
return {
title: rs.title,
dueAt: rs.due ? new Date(rs.due).toISOString() : null,
notes: r.notes
.filter((n) => rs.notes[n.key].include && rs.notes[n.key].text.trim())
.map((n) => {
const s = rs.notes[n.key];
const frame = frameFor(n, s);
return {
code: n.code,
shotId: n.shot?.id ?? null,
text: s.text.trim(),
versionId: n.shot ? s.versionId : null,
frame: frame != null && Number.isFinite(frame) && frame >= 0 ? Math.floor(frame) : null,
setChanges: !!s.versionId && s.setChanges,
};
}),
};
})
.filter((r) => r.notes.length > 0);
if (payload.length === 0) return;
startTransition(async () => {
try {
const res = await commitFeedback({ projectId, rounds: payload });
toast({
title: `${res.notes} note${res.notes === 1 ? "" : "s"} logged`,
description: `${res.comments} in the player · ${res.tasksChanged} task${res.tasksChanged === 1 ? "" : "s"} moved to Changes`,
});
reset();
onOpenChange(false);
router.refresh();
} catch (e) {
toast({ title: "Couldn't save feedback", description: (e as Error).message, variant: "destructive" });
}
});
};
const field = "rounded-md border border-zinc-700 bg-zinc-950 px-2 text-xs text-white placeholder:text-zinc-600 focus:border-amber-500/50 focus:outline-none";
return (
<Dialog open={open} onOpenChange={(o) => { if (!o) reset(); onOpenChange(o); }}>
<DialogContent className="max-h-[90vh] max-w-4xl overflow-y-auto">
<DialogHeader>
<DialogTitle className="flex items-center gap-2">
<MessageSquareText className="h-4 w-4 text-amber-400" />
Paste client feedback · {projectName}
</DialogTitle>
<DialogDescription>
{preview
? "Check where each note will go. Notes are saved in the player as client feedback and added to the board."
: "Paste the message as it arrived. Each note should start with a shot code; a line like “FEEDBACK 113 DUE Oct 7 12:00 PM” starts a round."}
</DialogDescription>
</DialogHeader>
{!preview ? (
<div className="space-y-3">
<textarea
autoFocus
value={input}
onChange={(e) => setInput(e.target.value)}
rows={12}
placeholder={"FEEDBACK 113 DUE Oct 7, 2026 12:00 PM\nUNG_113_008_040 The screen is partially peeking under the mask\nUNG_113_018_050 At frame 1018, the mask is still slipping"}
className={cn(field, "w-full resize-y py-2 font-mono text-[13px] leading-relaxed")}
/>
<div className="flex justify-end">
<Button onClick={() => read(input)} disabled={isPending || !input.trim()}>
{isPending ? "Reading…" : "Read feedback"}
</Button>
</div>
</div>
) : (
<div className="space-y-5">
{preview.ignored.length > 0 && (
<p className="text-xs text-zinc-500">
Skipped (no shot code): {preview.ignored.map((l) => `“${l}”`).join(", ")}
</p>
)}
{preview.rounds.map((r, ri) => {
const rs = rounds[ri];
if (!rs) return null;
return (
<div key={ri} className="space-y-2">
<div className="flex flex-wrap items-center gap-2">
<input
value={rs.title}
onChange={(e) => setRounds((all) => all.map((x, i) => (i === ri ? { ...x, title: e.target.value } : x)))}
className={cn(field, "h-8 w-56 text-sm font-medium")}
/>
<span className="text-xs text-zinc-500">due</span>
<input
type="datetime-local"
value={rs.due}
onChange={(e) => setRounds((all) => all.map((x, i) => (i === ri ? { ...x, due: e.target.value } : x)))}
className={cn(field, "h-8 [color-scheme:dark]")}
/>
{r.dueText && !rs.due && (
<span className="text-xs text-amber-400">Couldn’t read “{r.dueText}”, set it by hand</span>
)}
</div>
<div className="overflow-x-auto rounded-lg border border-zinc-800">
<table className="w-full text-xs">
<thead className="bg-zinc-950 text-left uppercase tracking-wider text-zinc-500">
<tr>
<th className="w-8 px-2 py-2" />
<th className="px-2 py-2">Shot</th>
<th className="px-2 py-2">Note</th>
<th className="px-2 py-2">Version</th>
<th className="px-2 py-2">Frame</th>
<th className="px-2 py-2" title="Move the task to Changes">Changes</th>
</tr>
</thead>
<tbody className="divide-y divide-zinc-800">
{r.notes.map((n) => {
const s = rs.notes[n.key];
const v = n.versions.find((x) => x.id === s.versionId) ?? null;
const frame = frameFor(n, s);
return (
<tr key={n.key} className={cn("align-top", !s.include && "opacity-40")}>
<td className="px-2 py-2">
<input
type="checkbox"
checked={s.include}
onChange={(e) => updateNote(ri, n.key, { include: e.target.checked })}
className="mt-1 accent-amber-500"
/>
</td>
<td className="whitespace-nowrap px-2 py-2 font-mono">
{n.shot ? (
<span className="text-amber-400">{n.shot.shotCode}</span>
) : (
<div className="space-y-1">
<span className="flex items-center gap-1 text-red-400">
<AlertTriangle className="h-3 w-3" /> {n.code}
</span>
{n.suggestion ? (
<button
type="button"
onClick={() => applySuggestion(n.code, n.suggestion!)}
className="flex items-center gap-1 font-sans text-zinc-400 hover:text-amber-400"
>
<Link2 className="h-3 w-3" /> Use {n.suggestion}
</button>
) : (
<span className="block font-sans text-zinc-500">Not in project; flag only</span>
)}
</div>
)}
</td>
<td className="min-w-[16rem] px-2 py-2">
<textarea
value={s.text}
onChange={(e) => updateNote(ri, n.key, { text: e.target.value })}
rows={Math.min(5, Math.max(1, Math.ceil(s.text.length / 60)))}
className={cn(field, "w-full resize-y py-1 leading-snug")}
/>
</td>
<td className="px-2 py-2">
{n.versions.length > 0 ? (
<select
value={s.versionId ?? ""}
onChange={(e) => updateNote(ri, n.key, { versionId: e.target.value || null, frame: null })}
className={cn(field, "h-7")}
>
{n.versions.map((o) => (
<option key={o.id} value={o.id}>
{o.label}
{o.sent ? ` · sent${o.sharedAt ? " " + format(new Date(o.sharedAt), "d MMM") : ""}` : " · not sent"}
</option>
))}
<option value="">Board only</option>
</select>
) : (
<span className="text-zinc-500">{n.shot ? "No versions; board only" : "—"}</span>
)}
{v && !v.sent && <span className="mt-1 block text-amber-400/80">Not sent to client</span>}
</td>
<td className="px-2 py-2">
{s.versionId ? (
<>
<input
inputMode="numeric"
value={s.frame ?? (frame != null ? String(frame) : "")}
onChange={(e) => updateNote(ri, n.key, { frame: e.target.value.replace(/\D/g, "") })}
placeholder="0"
className={cn(field, "h-7 w-16 font-mono")}
/>
{n.quotedFrame != null && s.frame === null && v && (
<span className="mt-1 block whitespace-nowrap text-zinc-500">
{v.fromComp ? `comp ${n.quotedFrame}` : `as quoted`}
</span>
)}
</>
) : (
<span className="text-zinc-600">—</span>
)}
</td>
<td className="px-2 py-2 text-center">
{v?.taskId ? (
<input
type="checkbox"
checked={s.setChanges}
disabled={v.taskStatus === "CHANGES"}
title={v.taskStatus === "CHANGES" ? "Already in Changes" : "Move the task to Changes"}
onChange={(e) => updateNote(ri, n.key, { setChanges: e.target.checked })}
className="mt-1 accent-amber-500"
/>
) : (
<span className="text-zinc-600">—</span>
)}
</td>
</tr>
);
})}
</tbody>
</table>
</div>
</div>
);
})}
<div className="flex flex-wrap items-center justify-between gap-2">
<Button variant="ghost" onClick={() => setPreview(null)} disabled={isPending}>
<ArrowLeft /> Edit paste
</Button>
<Button onClick={save} disabled={isPending || included.length === 0}>
{isPending ? "Saving…" : `Save ${included.length} note${included.length === 1 ? "" : "s"}`}
</Button>
</div>
</div>
)}
</DialogContent>
</Dialog>
);
}
+169
View File
@@ -0,0 +1,169 @@
import { auth } from "@/auth";
import { db } from "@/lib/db";
import { redirect } from "next/navigation";
import { suggestShot } from "@/lib/board-parse";
import { BoardClient, type BoardProject } from "./BoardClient";
export const metadata = { title: "Board" };
// Done lines stay visible this long so "what did we get through" is answerable
const DONE_WINDOW_MS = 7 * 86400000;
export default async function BoardPage({
searchParams,
}: {
searchParams: Promise<{ who?: string }>;
}) {
const session = await auth();
if (!session?.user) redirect("/login");
if (session.user.role === "CLIENT") redirect("/dashboard");
const { who } = await searchParams;
const doneSince = new Date(Date.now() - DONE_WINDOW_MS);
const [projects, users] = await Promise.all([
db.project.findMany({
where: { status: { in: ["ACTIVE", "ON_HOLD"] } },
orderBy: [{ status: "asc" }, { name: "asc" }],
select: {
id: true,
name: true,
code: true,
status: true,
boardStatus: true,
boardStatusAt: true,
milestones: { orderBy: { date: "asc" } },
boardItems: {
where: { OR: [{ doneAt: null }, { doneAt: { gte: doneSince } }] },
orderBy: { sortOrder: "asc" },
include: {
assignee: { select: { id: true, name: true, image: true } },
round: { select: { id: true, title: true, dueAt: true } },
shot: {
select: {
id: true,
shotCode: true,
status: true,
},
},
},
},
},
}),
db.user.findMany({
where: { isActive: true, role: { not: "CLIENT" } },
select: { id: true, name: true, email: true, image: true },
orderBy: { name: "asc" },
}),
]);
const projectIds = projects.map((p) => p.id);
// Latest version per linked shot — versions hang off the shot or its task
const linkedShotIds = [...new Set(projects.flatMap((p) => p.boardItems.map((i) => i.shotId).filter(Boolean) as string[]))];
const latestByShot = new Map<string, { id: string; versionNumber: number; approvalStatus: string; isClientVisible: boolean }>();
if (linkedShotIds.length) {
const versions = await db.version.findMany({
where: { OR: [{ shotId: { in: linkedShotIds } }, { task: { shotId: { in: linkedShotIds } } }] },
orderBy: { createdAt: "desc" },
select: {
id: true, versionNumber: true, approvalStatus: true, isClientVisible: true,
shotId: true, task: { select: { shotId: true } },
},
});
for (const v of versions) {
const sid = v.shotId ?? v.task?.shotId;
if (sid && !latestByShot.has(sid)) latestByShot.set(sid, v);
}
}
// Pasted-feedback lines link to the comment they were saved as
const commentIds = projects.flatMap((p) => p.boardItems.map((i) => i.commentId).filter(Boolean) as string[]);
const commentVersion = new Map(
(commentIds.length
? await db.comment.findMany({ where: { id: { in: commentIds } }, select: { id: true, versionId: true, frameNumber: true } })
: []
).map((c) => [c.id, c]),
);
const shotCounts = await db.shot.groupBy({
by: ["projectId", "status"],
where: { projectId: { in: projectIds } },
_count: { _all: true },
});
// Lines whose code did not match a shot when typed: the shot may exist now,
// or there may be an obvious near-miss (DH2_004_100 → DH2_VFX_004_100).
const flaggedProjects = projects.filter((p) => p.boardItems.some((i) => i.code && !i.shotId));
const shotsByProject = new Map(
await Promise.all(
flaggedProjects.map(async (p) => [
p.id,
await db.shot.findMany({
where: { projectId: p.id },
select: { id: true, shotCode: true, clientCode: true },
}),
] as const),
),
);
const data: BoardProject[] = projects.map((p) => {
const counts = shotCounts.filter((c) => c.projectId === p.id);
const shots = shotsByProject.get(p.id) ?? [];
return {
id: p.id,
name: p.name,
code: p.code,
status: p.status,
boardStatus: p.boardStatus,
boardStatusAt: p.boardStatusAt?.toISOString() ?? null,
shotTotal: counts.reduce((n, c) => n + c._count._all, 0),
shotComplete: counts.find((c) => c.status === "COMPLETE")?._count._all ?? 0,
milestones: p.milestones.map((m) => ({
id: m.id,
label: m.label,
date: m.date.toISOString(),
doneAt: m.doneAt?.toISOString() ?? null,
})),
items: p.boardItems.map((i) => {
const v = i.shot ? latestByShot.get(i.shot.id) : undefined;
const nowMatches = !i.shotId && i.code
? shots.find((s) => s.shotCode.toUpperCase() === i.code!.toUpperCase())
: undefined;
const suggestion = !i.shotId && i.code && !nowMatches ? suggestShot(i.code, shots) : null;
return {
id: i.id,
text: i.text,
code: i.code,
group: i.group,
waitingOn: i.waitingOn,
round: i.round ? { id: i.round.id, title: i.round.title, dueAt: i.round.dueAt?.toISOString() ?? null } : null,
comment: i.commentId && commentVersion.has(i.commentId)
? { versionId: commentVersion.get(i.commentId)!.versionId, frame: commentVersion.get(i.commentId)!.frameNumber }
: null,
doneAt: i.doneAt?.toISOString() ?? null,
assignee: i.assignee,
shot: i.shot
? {
id: i.shot.id,
shotCode: i.shot.shotCode,
status: i.shot.status,
latest: v
? {
id: v.id,
versionNumber: v.versionNumber,
approvalStatus: v.approvalStatus,
isClientVisible: v.isClientVisible,
}
: null,
}
: null,
// Shot created since the line was typed: offer to link it
relinkTo: nowMatches?.shotCode ?? suggestion?.shotCode ?? null,
relinkIsExact: !!nowMatches,
};
}),
};
});
return <BoardClient projects={data} users={users} who={who ?? null} />;
}
+1 -1
View File
@@ -59,7 +59,7 @@ export default async function ClientDetailPage({
}; };
return ( return (
<div className="p-6 max-w-5xl mx-auto space-y-6"> <div className="p-4 md:p-6 max-w-5xl mx-auto space-y-6">
{/* Back */} {/* Back */}
<Link <Link
href="/clients" href="/clients"
+1 -1
View File
@@ -26,7 +26,7 @@ export default async function ClientsPage() {
const clients = await getClients(); const clients = await getClients();
return ( return (
<div className="p-6 max-w-5xl mx-auto space-y-6"> <div className="p-4 md:p-6 max-w-5xl mx-auto space-y-6">
{/* Header */} {/* Header */}
<div className="flex items-center justify-between"> <div className="flex items-center justify-between">
<div> <div>
+168 -94
View File
@@ -1,58 +1,69 @@
import { auth } from "@/auth"; import { auth } from "@/auth";
import { db } from "@/lib/db"; import { db } from "@/lib/db";
import { StatsCards } from "@/components/dashboard/StatsCards"; import { StatsCards } from "@/components/dashboard/StatsCards";
import { BlockedQueue } from "@/components/dashboard/BlockedQueue";
import { FarmStrip } from "@/components/dashboard/FarmStrip";
import { DeliveryCountdown } from "@/components/dashboard/DeliveryCountdown";
import { QcQueue } from "@/components/dashboard/QcQueue";
import { AwaitingDelivery } from "@/components/dashboard/AwaitingDelivery";
import { LogRequestButton } from "@/components/dashboard/LogRequestButton";
import { RecentDeliveries } from "@/components/dashboard/RecentDeliveries";
import { WhoseCourt } from "@/components/dashboard/WhoseCourt";
import { ShotQueue } from "@/components/dashboard/ShotQueue"; import { ShotQueue } from "@/components/dashboard/ShotQueue";
import { RecentActivity } from "@/components/dashboard/RecentActivity";
import { TaskWidgets } from "@/components/dashboard/TaskWidgets"; import { TaskWidgets } from "@/components/dashboard/TaskWidgets";
import { ScheduleWidgets } from "@/components/dashboard/ScheduleWidgets"; import { ScheduleWidgets } from "@/components/dashboard/ScheduleWidgets";
import {
getAwaitingDelivery,
getBlockedExports,
getDeliveryCountdown,
getFarmStatus,
getOpsCounts,
getQcQueue,
getQcStaleHours,
getRecentDeliveries,
getWhoseCourt,
} from "@/lib/dashboard/ops";
import { listDeliveryRequests } from "@/lib/render-pipeline/delivery-requests";
import type { DashboardStats } from "@/types"; import type { DashboardStats } from "@/types";
export const metadata = { title: "Dashboard" }; export const metadata = { title: "Dashboard" };
// Queue depth and machine state are stale the moment they are cached.
export const dynamic = "force-dynamic";
/**
* The dashboard answers one question: can we ship what is due, and what is
* stopping us? Everything on it is pipeline state — exports, QC, deliveries,
* worker heartbeats — rather than anything a person has to maintain by hand.
*/
async function getDashboardData(userId: string, role: string) { async function getDashboardData(userId: string, role: string) {
const isArtist = role === "ARTIST"; const isArtist = role === "ARTIST";
const isClient = role === "CLIENT"; const isClient = role === "CLIENT";
const now = new Date();
const todayStart = new Date(now.getFullYear(), now.getMonth(), now.getDate());
const todayEnd = new Date(todayStart.getTime() + 86400000);
const [awaitingReview, needsRevisions, approved, activeProjects, // Producers see the floor; an artist sees the failures that are theirs.
tasksDueToday, tasksInReview, tasksOverdue, myTasksCount] = const [counts, blocked, farm, episodes, qcQueue, qcStaleHours, deliveries, awaitingDelivery, openRequests, court] =
await Promise.all([ await Promise.all([
db.version.count({ where: { approvalStatus: "PENDING_REVIEW" } }), getOpsCounts(isArtist ? userId : undefined),
db.version.count({ where: { approvalStatus: "NEEDS_CHANGES" } }), getBlockedExports(isArtist ? { artistId: userId } : {}),
db.version.count({ where: { approvalStatus: "APPROVED" } }), getFarmStatus(),
db.project.count({ where: { status: "ACTIVE" } }), getDeliveryCountdown(),
db.task.count({ isArtist || isClient ? [] : getQcQueue(),
where: { getQcStaleHours(),
dueDate: { gte: todayStart, lt: todayEnd }, isArtist || isClient ? [] : getRecentDeliveries(),
status: { not: "DONE" }, isArtist || isClient ? [] : getAwaitingDelivery(),
...(isArtist ? { assignedArtistId: userId } : {}), isArtist || isClient ? [] : listDeliveryRequests({ openOnly: true }),
}, isArtist || isClient ? null : getWhoseCourt(),
}),
db.task.count({
where: {
status: { in: ["INTERNAL_REVIEW", "CLIENT_REVIEW"] },
...(isArtist ? { assignedArtistId: userId } : {}),
},
}),
db.task.count({
where: {
dueDate: { lt: todayStart },
status: { not: "DONE" },
...(isArtist ? { assignedArtistId: userId } : {}),
},
}),
db.task.count({
where: { assignedArtistId: userId, status: { not: "DONE" } },
}),
]); ]);
const shotsWhere = isArtist ? { artistId: userId } : {}; // An artist's own shots come first; everyone else sees the floor.
const shots = await db.shot.findMany({ const shots = await db.shot.findMany({
where: { ...shotsWhere, status: { not: "COMPLETE" } }, where: {
...(isArtist ? { artistId: userId } : {}),
status: { not: "COMPLETE" },
project: { status: { in: ["ACTIVE", "ON_HOLD"] } },
},
take: 15, take: 15,
orderBy: { updatedAt: "desc" }, orderBy: [{ dueDate: { sort: "asc", nulls: "last" } }, { updatedAt: "desc" }],
include: { include: {
artist: { select: { id: true, name: true, image: true, email: true } }, artist: { select: { id: true, name: true, image: true, email: true } },
versions: { versions: {
@@ -63,12 +74,8 @@ async function getDashboardData(userId: string, role: string) {
}, },
}); });
// My tasks (for widget)
const myTasks = await db.task.findMany({ const myTasks = await db.task.findMany({
where: { where: { assignedArtistId: userId, status: { not: "DONE" } },
assignedArtistId: userId,
status: { not: "DONE" },
},
take: 8, take: 8,
orderBy: [{ dueDate: "asc" }, { priority: "desc" }], orderBy: [{ dueDate: "asc" }, { priority: "desc" }],
include: { include: {
@@ -78,7 +85,6 @@ async function getDashboardData(userId: string, role: string) {
}, },
}); });
// Tasks in review (for supervisors/producers)
const reviewTasks = isArtist || isClient ? [] : await db.task.findMany({ const reviewTasks = isArtist || isClient ? [] : await db.task.findMany({
where: { status: { in: ["INTERNAL_REVIEW", "CLIENT_REVIEW"] } }, where: { status: { in: ["INTERNAL_REVIEW", "CLIENT_REVIEW"] } },
take: 8, take: 8,
@@ -91,14 +97,8 @@ async function getDashboardData(userId: string, role: string) {
}, },
}); });
const activity = await db.notification.findMany({ // Schedule overview (producers/supervisors/admins) — unchanged; it reads the
where: isClient ? { userId } : {}, // schedule page's own data rather than anything the pipeline owns.
take: 20,
orderBy: { createdAt: "desc" },
include: { user: { select: { name: true, image: true } } },
});
// Schedule data (for producers/supervisors/admins)
const scheduledTasks = const scheduledTasks =
!isArtist && !isClient !isArtist && !isClient
? await db.task.findMany({ ? await db.task.findMany({
@@ -119,46 +119,59 @@ async function getDashboardData(userId: string, role: string) {
!isArtist && !isClient !isArtist && !isClient
? await db.user.findMany({ ? await db.user.findMany({
where: { isActive: true, role: { not: "CLIENT" } }, where: { isActive: true, role: { not: "CLIENT" } },
select: { select: { id: true, name: true, email: true, image: true, role: true },
id: true,
name: true,
email: true,
image: true,
role: true,
},
orderBy: { name: "asc" }, orderBy: { name: "asc" },
}) })
: []; : [];
const stats: DashboardStats = { const stats: DashboardStats = counts;
awaitingReview,
needsRevisions,
approved,
overdue: tasksOverdue,
activeProjects,
tasksDueToday,
tasksInReview,
tasksOverdue,
myTasksCount,
};
return { stats, shots, activity, myTasks, reviewTasks, scheduledTasks, scheduleArtists }; return {
stats,
blocked,
farm,
episodes,
qcQueue,
qcStaleHours,
deliveries,
awaitingDelivery,
openRequests,
court,
shots,
myTasks,
reviewTasks,
scheduledTasks,
scheduleArtists,
};
} }
export default async function DashboardPage() { export default async function DashboardPage() {
const session = await auth(); const session = await auth();
if (!session?.user) return null; if (!session?.user) return null;
const { stats, shots, activity, myTasks, reviewTasks, scheduledTasks, scheduleArtists } =
await getDashboardData(session.user.id, session.user.role);
const isClient = session.user.role === "CLIENT"; const isClient = session.user.role === "CLIENT";
const canSeeSchedule = ["ADMIN", "PRODUCER", "SUPERVISOR"].includes( const isArtistRole = session.user.role === "ARTIST";
session.user.role const canSeeSchedule = ["ADMIN", "PRODUCER", "SUPERVISOR"].includes(session.user.role);
); const {
stats,
blocked,
farm,
episodes,
qcQueue,
qcStaleHours,
deliveries,
awaitingDelivery,
openRequests,
court,
shots,
myTasks,
reviewTasks,
scheduledTasks,
scheduleArtists,
} = await getDashboardData(session.user.id, session.user.role);
return ( return (
<div className="p-8 space-y-6 max-w-[1600px] mx-auto"> <div className="p-4 md:p-8 space-y-6 max-w-[1600px] mx-auto">
<div className="mb-4"> <div className="mb-4">
<h1 className="text-3xl font-bold text-white">Dashboard</h1> <h1 className="text-3xl font-bold text-white">Dashboard</h1>
<p className="text-zinc-400 mt-1"> <p className="text-zinc-400 mt-1">
@@ -166,7 +179,82 @@ export default async function DashboardPage() {
</p> </p>
</div> </div>
<StatsCards stats={stats} /> {!isClient && <StatsCards stats={stats} />}
{/* Rows only clear by being dealt with; the heading stays so there is
always somewhere to log what a client just asked for. */}
{!isClient && !isArtistRole && (
<div className="space-y-3">
<div className="flex items-center justify-between gap-3">
<h2
className={
openRequests.length + awaitingDelivery.length > 0
? "text-sm font-semibold text-amber-400 uppercase tracking-wide"
: "text-sm font-semibold text-muted-foreground uppercase tracking-wide"
}
>
Awaiting delivery
</h2>
{canSeeSchedule && <LogRequestButton />}
</div>
<AwaitingDelivery requests={openRequests} packages={awaitingDelivery} />
</div>
)}
{!isClient && (
<div className="space-y-3">
<h2 className="text-sm font-semibold text-muted-foreground uppercase tracking-wide">
Delivery countdown
</h2>
<DeliveryCountdown episodes={episodes} />
</div>
)}
{!isClient && (
<div id="blocked" className="grid grid-cols-1 xl:grid-cols-3 gap-6 items-start scroll-mt-6">
<div className="xl:col-span-2 space-y-3">
<h2 className="text-sm font-semibold text-muted-foreground uppercase tracking-wide">
{isArtistRole ? "Your blocked shots" : "Blocked — needs a human"}
</h2>
<BlockedQueue blocked={blocked} />
</div>
<div className="space-y-3">
<h2 className="text-sm font-semibold text-muted-foreground uppercase tracking-wide">
Render farm
</h2>
<FarmStrip farm={farm} />
</div>
</div>
)}
{!isClient && !isArtistRole && (
<div className="grid grid-cols-1 xl:grid-cols-3 gap-6 items-start">
<div className="xl:col-span-2 space-y-3">
<h2 className="text-sm font-semibold text-muted-foreground uppercase tracking-wide">
QC queue
</h2>
<QcQueue entries={qcQueue} staleHours={qcStaleHours} />
</div>
<div className="space-y-6">
<div className="space-y-3">
<h2 className="text-sm font-semibold text-muted-foreground uppercase tracking-wide">
Deliveries
</h2>
<RecentDeliveries deliveries={deliveries} />
</div>
{court && (
<div className="space-y-3">
<h2 className="text-sm font-semibold text-muted-foreground uppercase tracking-wide">
Whose court
</h2>
<WhoseCourt court={court} />
</div>
)}
</div>
</div>
)}
{!isClient && ( {!isClient && (
<TaskWidgets <TaskWidgets
@@ -181,32 +269,18 @@ export default async function DashboardPage() {
<h2 className="text-sm font-semibold text-muted-foreground uppercase tracking-wide"> <h2 className="text-sm font-semibold text-muted-foreground uppercase tracking-wide">
Schedule Overview Schedule Overview
</h2> </h2>
<ScheduleWidgets <ScheduleWidgets scheduledTasks={scheduledTasks as any} artists={scheduleArtists} />
scheduledTasks={scheduledTasks as any}
artists={scheduleArtists}
/>
</div> </div>
)} )}
<div className="grid grid-cols-1 xl:grid-cols-3 gap-6"> <div className="space-y-3">
<div className="xl:col-span-2 space-y-3">
<h2 className="text-sm font-semibold text-muted-foreground uppercase tracking-wide"> <h2 className="text-sm font-semibold text-muted-foreground uppercase tracking-wide">
Shot Queue {session.user.role === "ARTIST" ? "My shots" : "Shots in flight"}
</h2> </h2>
<div className="rounded-lg border border-border bg-card p-1"> <div className="rounded-lg border border-border bg-card p-1">
<ShotQueue shots={shots as any} /> <ShotQueue shots={shots as any} />
</div> </div>
</div> </div>
<div className="space-y-3">
<h2 className="text-sm font-semibold text-muted-foreground uppercase tracking-wide">
Recent Activity
</h2>
<div className="rounded-lg border border-border bg-card h-[400px] overflow-hidden">
<RecentActivity activities={activity as any} />
</div>
</div>
</div>
</div> </div>
); );
} }
+3
View File
@@ -2,6 +2,7 @@ import { auth } from "@/auth";
import { redirect } from "next/navigation"; import { redirect } from "next/navigation";
import { Sidebar } from "@/components/layout/Sidebar"; import { Sidebar } from "@/components/layout/Sidebar";
import { Header } from "@/components/layout/Header"; import { Header } from "@/components/layout/Header";
import { MobileNavProvider } from "@/components/layout/MobileNav";
export default async function DashboardLayout({ export default async function DashboardLayout({
children, children,
@@ -12,6 +13,7 @@ export default async function DashboardLayout({
if (!session?.user) redirect("/login"); if (!session?.user) redirect("/login");
return ( return (
<MobileNavProvider>
<div className="flex h-screen bg-zinc-950 overflow-hidden print:block print:h-auto print:overflow-visible"> <div className="flex h-screen bg-zinc-950 overflow-hidden print:block print:h-auto print:overflow-visible">
<div className="print:hidden"> <div className="print:hidden">
<Sidebar /> <Sidebar />
@@ -25,5 +27,6 @@ export default async function DashboardLayout({
</main> </main>
</div> </div>
</div> </div>
</MobileNavProvider>
); );
} }
+214 -74
View File
@@ -1,12 +1,14 @@
"use client"; "use client";
import { useState } from "react"; import { useEffect, useState } from "react";
import Link from "next/link"; import Link from "next/link";
import { useQuery, useQueryClient } from "@tanstack/react-query"; import { useQuery, useQueryClient } from "@tanstack/react-query";
import { useSession } from "next-auth/react"; import { useSession } from "next-auth/react";
import { RefreshCw, RotateCcw, XCircle, CheckCircle2, Server, Package } from "lucide-react"; import { RefreshCw, RotateCcw, XCircle, CheckCircle2, Server, Package, ChevronLeft, ChevronRight, Search, X } from "lucide-react";
import { Button } from "@/components/ui/button"; import { Button } from "@/components/ui/button";
import { Input } from "@/components/ui/input";
import { Progress } from "@/components/ui/progress"; import { Progress } from "@/components/ui/progress";
import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
import { import {
Select, Select,
SelectContent, SelectContent,
@@ -51,37 +53,79 @@ interface QueueExport {
interface Props { interface Props {
projects: { id: string; name: string; code: string }[]; projects: { id: string; name: string; code: string }[];
/** Status to open filtered to, from `?status=` (see page.tsx). */
initialStatus?: string;
} }
export function PipelineQueueClient({ projects }: Props) { const PAGE_SIZE = 25;
const BLENDER_ACTIVE = ["QUEUED", "CLAIMED", "RUNNING"];
export function PipelineQueueClient({ projects, initialStatus = "all" }: Props) {
const { data: session } = useSession(); const { data: session } = useSession();
const { toast } = useToast(); const { toast } = useToast();
const queryClient = useQueryClient(); const queryClient = useQueryClient();
const [projectId, setProjectId] = useState<string>("all"); const [projectId, setProjectId] = useState<string>("all");
const [statusFilter, setStatusFilter] = useState<string>("all"); const [statusFilter, setStatusFilter] = useState<string>(initialStatus);
const [page, setPage] = useState(1);
const [searchInput, setSearchInput] = useState("");
const [search, setSearch] = useState("");
const isAdmin = ["ADMIN", "PRODUCER", "SUPERVISOR"].includes(session?.user?.role ?? ""); const isAdmin = ["ADMIN", "PRODUCER", "SUPERVISOR"].includes(session?.user?.role ?? "");
// Searched on the server (the table is paged there), so typing is debounced
// rather than firing a request per keystroke.
useEffect(() => {
const next = searchInput.trim();
if (next === search) return;
const t = setTimeout(() => {
setSearch(next);
setPage(1);
}, 300);
return () => clearTimeout(t);
}, [searchInput, search]);
const { data, isLoading, refetch, isFetching } = useQuery({ const { data, isLoading, refetch, isFetching } = useQuery({
queryKey: ["pipeline-queue", projectId, statusFilter], queryKey: ["pipeline-queue", projectId, statusFilter, search, page],
queryFn: async () => { queryFn: async () => {
const params = new URLSearchParams({ limit: "200" }); const params = new URLSearchParams({ limit: String(PAGE_SIZE), page: String(page) });
if (projectId !== "all") params.set("projectId", projectId); if (projectId !== "all") params.set("projectId", projectId);
if (statusFilter !== "all") params.set("status", statusFilter); if (statusFilter !== "all") params.set("status", statusFilter);
if (search) params.set("q", search);
const res = await fetch(`/api/render/queue?${params}`); const res = await fetch(`/api/render/queue?${params}`);
if (!res.ok) throw new Error("Failed to load queue"); if (!res.ok) throw new Error("Failed to load queue");
return res.json() as Promise<{ exports: QueueExport[]; pagination: { total: number } }>; return res.json() as Promise<{
exports: QueueExport[];
pagination: { page: number; total: number; pages: number };
statusCounts: Record<string, number>;
}>;
},
refetchInterval: 5000,
// Keep the current page on screen while the next one loads, instead of
// flashing "Loading…" on every page turn.
placeholderData: (previous) => previous,
});
// Fetched here rather than in the tab so the tab label can say how many are
// running: a Blender render must not become invisible by sitting in a tab.
const { data: blenderData } = useQuery({
queryKey: ["blender-jobs", projectId],
queryFn: async () => {
const qs = projectId !== "all" ? `?projectId=${encodeURIComponent(projectId)}` : "";
const res = await fetch(`/api/render/blender${qs}`);
if (!res.ok) throw new Error("Failed to load Blender jobs");
return res.json() as Promise<{ jobs: BlenderJobRow[] }>;
}, },
refetchInterval: 5000, refetchInterval: 5000,
}); });
const exports = data?.exports ?? []; const exports = data?.exports ?? [];
const counts = { const pagination = data?.pagination;
queued: exports.filter((e) => e.status === "QUEUED").length, const statusCounts = data?.statusCounts ?? {};
rendering: exports.filter((e) => e.status === "RENDERING").length, const countOf = (statuses: string[]) => statuses.reduce((n, s) => n + (statusCounts[s] ?? 0), 0);
failed: exports.filter((e) => FAILED_STATUSES.includes(e.status)).length, const totalExports = Object.values(statusCounts).reduce((n, c) => n + c, 0);
readyForQc: exports.filter((e) => e.status === "READY_FOR_QC").length, const blenderJobs = blenderData?.jobs ?? [];
readyForDelivery: exports.filter((e) => e.status === "READY_FOR_DELIVERY").length, const blenderActive = blenderJobs.filter((j) => BLENDER_ACTIVE.includes(j.status)).length;
}; const blenderFailed = blenderJobs.filter((j) => ["FAILED", "EXPIRED"].includes(j.status)).length;
async function action(exportId: string, verb: "retry" | "cancel" | "mark-done") { async function action(exportId: string, verb: "retry" | "cancel" | "mark-done") {
const res = await fetch(`/api/render/exports/${exportId}/${verb}`, { method: "POST" }); const res = await fetch(`/api/render/exports/${exportId}/${verb}`, { method: "POST" });
@@ -94,30 +138,56 @@ export function PipelineQueueClient({ projects }: Props) {
queryClient.invalidateQueries({ queryKey: ["pipeline-queue"] }); queryClient.invalidateQueries({ queryKey: ["pipeline-queue"] });
} }
const cards: { label: string; value: number; className?: string }[] = [ const cards: { label: string; value: number; status?: string; className?: string }[] = [
{ label: "Queued", value: counts.queued }, { label: "Queued", value: countOf(["QUEUED"]), status: "QUEUED" },
{ label: "Rendering", value: counts.rendering, className: "text-blue-400" }, { label: "Rendering", value: countOf(["RENDERING"]), status: "RENDERING", className: "text-blue-400" },
{ label: "Failed", value: counts.failed, className: "text-red-400" }, // Several statuses count as failed and the filter takes one, so this card
{ label: "Ready for QC", value: counts.readyForQc, className: "text-amber-400" }, // is a figure only.
{ label: "Ready for Delivery", value: counts.readyForDelivery, className: "text-green-400" }, { label: "Failed", value: countOf(FAILED_STATUSES), className: "text-red-400" },
{ label: "Ready for QC", value: countOf(["READY_FOR_QC"]), status: "READY_FOR_QC", className: "text-amber-400" },
{
label: "Ready for Delivery",
value: countOf(["READY_FOR_DELIVERY"]),
status: "READY_FOR_DELIVERY",
className: "text-green-400",
},
]; ];
const changeProject = (id: string) => {
setProjectId(id);
setPage(1);
};
const changeStatus = (status: string) => {
setStatusFilter(status);
setPage(1);
};
const firstRow = pagination && pagination.total > 0 ? (pagination.page - 1) * PAGE_SIZE + 1 : 0;
const lastRow = pagination ? Math.min(pagination.page * PAGE_SIZE, pagination.total) : 0;
return ( return (
<div className="p-6 space-y-6"> <div className="p-4 md:p-6 space-y-6">
<div className="flex items-center justify-between gap-4 flex-wrap"> <div className="flex items-center justify-between gap-4 flex-wrap">
<div> <div>
<h1 className="text-2xl font-semibold text-white">Render Queue</h1> <h1 className="text-2xl font-semibold text-white">Render Queue</h1>
<p className="text-sm text-zinc-400 mt-1"> <p className="text-sm text-zinc-400 mt-1">
Exports queued from the AE panel — live status, retries and history After Effects exports and Blender renders — live status, retries and history
</p> </p>
</div> </div>
<div className="flex items-center gap-2"> <div className="flex items-center gap-2 flex-wrap">
<Link href="/pipeline/deliveries"> <Select value={projectId} onValueChange={changeProject}>
<Button variant="outline" size="sm"> <SelectTrigger className="w-56">
<Package className="h-4 w-4 mr-2" /> <SelectValue placeholder="All projects" />
Deliveries </SelectTrigger>
</Button> <SelectContent>
</Link> <SelectItem value="all">All projects</SelectItem>
{projects.map((p) => (
<SelectItem key={p.id} value={p.id}>
{p.name}
</SelectItem>
))}
</SelectContent>
</Select>
<Link href="/pipeline/deliveries"> <Link href="/pipeline/deliveries">
<Button variant="outline" size="sm"> <Button variant="outline" size="sm">
<Package className="h-4 w-4 mr-2" /> <Package className="h-4 w-4 mr-2" />
@@ -136,32 +206,82 @@ export function PipelineQueueClient({ projects }: Props) {
</div> </div>
</div> </div>
{/* Summary cards */} <Tabs defaultValue="exports" className="space-y-4">
<TabsList className="bg-zinc-900 border border-zinc-800">
<TabsTrigger value="exports">
After Effects exports
<span className="ml-2 text-xs text-zinc-500">{totalExports}</span>
</TabsTrigger>
<TabsTrigger value="blender">
Blender renders
{blenderActive > 0 ? (
<span className="ml-2 rounded-full bg-blue-500/20 px-1.5 text-xs text-blue-400">
{blenderActive} active
</span>
) : blenderFailed > 0 ? (
<span className="ml-2 rounded-full bg-red-500/20 px-1.5 text-xs text-red-400">
{blenderFailed} failed
</span>
) : (
<span className="ml-2 text-xs text-zinc-500">{blenderJobs.length}</span>
)}
</TabsTrigger>
</TabsList>
<TabsContent value="exports" className="space-y-4 mt-0">
{/* Summary cards — each one with a status filters the table to what it counts */}
<div className="grid grid-cols-2 sm:grid-cols-5 gap-3"> <div className="grid grid-cols-2 sm:grid-cols-5 gap-3">
{cards.map((c) => ( {cards.map((c) => {
<div key={c.label} className="rounded-lg border border-zinc-800 bg-zinc-900 px-4 py-3"> const selected = c.status !== undefined && statusFilter === c.status;
const body = (
<>
<div className={cn("text-2xl font-semibold text-white", c.className)}>{c.value}</div> <div className={cn("text-2xl font-semibold text-white", c.className)}>{c.value}</div>
<div className="text-xs text-zinc-400 mt-0.5">{c.label}</div> <div className="text-xs text-zinc-400 mt-0.5">{c.label}</div>
</>
);
return c.status ? (
<button
key={c.label}
type="button"
onClick={() => changeStatus(selected ? "all" : c.status!)}
className={cn(
"rounded-lg border bg-zinc-900 px-4 py-3 text-left transition-colors hover:border-zinc-600",
selected ? "border-zinc-500" : "border-zinc-800"
)}
>
{body}
</button>
) : (
<div key={c.label} className="rounded-lg border border-zinc-800 bg-zinc-900 px-4 py-3">
{body}
</div> </div>
))} );
})}
</div> </div>
{/* Filters */} <div className="flex items-center gap-2 flex-wrap">
<div className="flex items-center gap-3 flex-wrap"> <div className="relative w-full sm:w-72">
<Select value={projectId} onValueChange={setProjectId}> <Search className="pointer-events-none absolute left-2.5 top-1/2 h-4 w-4 -translate-y-1/2 text-zinc-500" />
<SelectTrigger className="w-56"> <Input
<SelectValue placeholder="All projects" /> value={searchInput}
</SelectTrigger> onChange={(e) => setSearchInput(e.target.value)}
<SelectContent> onKeyDown={(e) => e.key === "Escape" && setSearchInput("")}
<SelectItem value="all">All projects</SelectItem> placeholder="Search shots, e.g. UNG_114"
{projects.map((p) => ( aria-label="Search exports by shot code"
<SelectItem key={p.id} value={p.id}> className="pl-8 pr-8"
{p.name} />
</SelectItem> {searchInput && (
))} <button
</SelectContent> type="button"
</Select> onClick={() => setSearchInput("")}
<Select value={statusFilter} onValueChange={setStatusFilter}> className="absolute right-2 top-1/2 -translate-y-1/2 text-zinc-500 hover:text-zinc-300"
aria-label="Clear search"
>
<X className="h-4 w-4" />
</button>
)}
</div>
<Select value={statusFilter} onValueChange={changeStatus}>
<SelectTrigger className="w-56"> <SelectTrigger className="w-56">
<SelectValue placeholder="All statuses" /> <SelectValue placeholder="All statuses" />
</SelectTrigger> </SelectTrigger>
@@ -176,7 +296,6 @@ export function PipelineQueueClient({ projects }: Props) {
</Select> </Select>
</div> </div>
{/* Table */}
<div className="rounded-lg border border-zinc-800 overflow-x-auto"> <div className="rounded-lg border border-zinc-800 overflow-x-auto">
<table className="w-full text-sm"> <table className="w-full text-sm">
<thead> <thead>
@@ -201,7 +320,11 @@ export function PipelineQueueClient({ projects }: Props) {
) : exports.length === 0 ? ( ) : exports.length === 0 ? (
<tr> <tr>
<td colSpan={8} className="px-4 py-10 text-center text-zinc-500"> <td colSpan={8} className="px-4 py-10 text-center text-zinc-500">
No exports yet — queue one from the After Effects panel {search
? `No exports match “${search}”`
: statusFilter === "all"
? "No exports yet — queue one from the After Effects panel"
: `No exports are ${statusLabel(statusFilter).toLowerCase()}`}
</td> </td>
</tr> </tr>
) : ( ) : (
@@ -244,9 +367,7 @@ export function PipelineQueueClient({ projects }: Props) {
)} )}
</td> </td>
<td className="px-4 py-2.5 text-zinc-400">{e.job?.machineName ?? "—"}</td> <td className="px-4 py-2.5 text-zinc-400">{e.job?.machineName ?? "—"}</td>
<td className="px-4 py-2.5 text-zinc-400"> <td className="px-4 py-2.5 text-zinc-400">{e.job ? `${e.job.attempt}` : "—"}</td>
{e.job ? `${e.job.attempt}` : "—"}
</td>
<td className="px-4 py-2.5 text-zinc-500 text-xs whitespace-nowrap"> <td className="px-4 py-2.5 text-zinc-500 text-xs whitespace-nowrap">
{new Date(e.createdAt).toLocaleString()} {new Date(e.createdAt).toLocaleString()}
</td> </td>
@@ -281,7 +402,35 @@ export function PipelineQueueClient({ projects }: Props) {
</table> </table>
</div> </div>
<BlenderQueue projectId={projectId} /> {pagination && pagination.pages > 1 && (
<div className="flex items-center justify-between text-sm text-zinc-400">
<span>
{firstRow}–{lastRow} of {pagination.total}
</span>
<div className="flex items-center gap-2">
<Button variant="outline" size="sm" disabled={page <= 1} onClick={() => setPage((p) => p - 1)}>
<ChevronLeft className="h-4 w-4" />
</Button>
<span className="text-xs">
Page {pagination.page} of {pagination.pages}
</span>
<Button
variant="outline"
size="sm"
disabled={page >= pagination.pages}
onClick={() => setPage((p) => p + 1)}
>
<ChevronRight className="h-4 w-4" />
</Button>
</div>
</div>
)}
</TabsContent>
<TabsContent value="blender" className="mt-0">
<BlenderQueue jobs={blenderJobs} loaded={blenderData !== undefined} />
</TabsContent>
</Tabs>
</div> </div>
); );
} }
@@ -318,24 +467,13 @@ const BLENDER_STATUS_STYLES: Record<string, string> = {
/** /**
* Standalone Blender renders. They have no Export behind them, so they cannot * Standalone Blender renders. They have no Export behind them, so they cannot
* appear in the table above — but they share the queue, and a render nobody can * appear in the exports table — but they share the queue, and a render nobody
* see is a render nobody can retry. * can see is a render nobody can retry.
*/ */
function BlenderQueue({ projectId }: { projectId: string }) { function BlenderQueue({ jobs, loaded }: { jobs: BlenderJobRow[]; loaded: boolean }) {
const { toast } = useToast(); const { toast } = useToast();
const queryClient = useQueryClient(); const queryClient = useQueryClient();
const { data } = useQuery({
queryKey: ["blender-jobs", projectId],
queryFn: async () => {
const qs = projectId && projectId !== "all" ? `?projectId=${encodeURIComponent(projectId)}` : "";
const res = await fetch(`/api/render/blender${qs}`);
if (!res.ok) throw new Error("Failed to load Blender jobs");
return res.json() as Promise<{ jobs: BlenderJobRow[] }>;
},
refetchInterval: 5000,
});
async function jobAction(id: string, verb: "cancel" | "retry") { async function jobAction(id: string, verb: "cancel" | "retry") {
const res = await fetch(`/api/render/blender/${id}?action=${verb}`, { method: "POST" }); const res = await fetch(`/api/render/blender/${id}?action=${verb}`, { method: "POST" });
if (!res.ok) { if (!res.ok) {
@@ -345,14 +483,16 @@ function BlenderQueue({ projectId }: { projectId: string }) {
queryClient.invalidateQueries({ queryKey: ["blender-jobs"] }); queryClient.invalidateQueries({ queryKey: ["blender-jobs"] });
} }
const jobs = data?.jobs ?? []; if (jobs.length === 0) {
if (jobs.length === 0) return null; return (
<div className="rounded-lg border border-zinc-800 px-4 py-10 text-center text-sm text-zinc-500">
{loaded ? "No Blender renders yet — submit one from the Blender panel" : "Loading…"}
</div>
);
}
return ( return (
<div className="rounded-lg border border-zinc-800 bg-zinc-900/40"> <div className="rounded-lg border border-zinc-800 bg-zinc-900/40">
<div className="px-4 py-2.5 border-b border-zinc-800 text-sm font-medium text-white">
Blender renders
</div>
<div className="divide-y divide-zinc-800/60"> <div className="divide-y divide-zinc-800/60">
{jobs.map((j) => ( {jobs.map((j) => (
<div key={j.id} className="px-4 py-3 text-sm"> <div key={j.id} className="px-4 py-3 text-sm">
@@ -3,11 +3,14 @@
import { useState } from "react"; import { useState } from "react";
import Link from "next/link"; import Link from "next/link";
import { useQuery, useQueryClient } from "@tanstack/react-query"; import { useQuery, useQueryClient } from "@tanstack/react-query";
import { ArrowLeft, Package, CheckCircle2, XCircle, RefreshCw } from "lucide-react"; import { ArrowLeft, Package, CheckCircle2, XCircle, RefreshCw, Upload } from "lucide-react";
import { Button } from "@/components/ui/button"; import { Button } from "@/components/ui/button";
import { useToast } from "@/components/ui/use-toast"; import { useToast } from "@/components/ui/use-toast";
import { cn } from "@/lib/utils"; import { cn } from "@/lib/utils";
import { handoffStage } from "@/lib/render-pipeline/delivery-handoff";
import { DELIVERY_STATUS_STYLES, statusLabel } from "../status-colors"; import { DELIVERY_STATUS_STYLES, statusLabel } from "../status-colors";
import { RecordShareDialog, RecordUploadDialog } from "./HandoffDialogs";
import { RequestsPanel } from "./RequestsPanel";
interface ReadyExport { interface ReadyExport {
exportId: string; exportId: string;
@@ -29,19 +32,31 @@ interface PackageRow {
id: string; id: string;
packageNumber: number; packageNumber: number;
name: string; name: string;
kind: "EXR_DELIVERY" | "MOV_REVIEW";
episode: string; episode: string;
status: string; status: string;
rootPath: string | null; rootPath: string | null;
errorMessage: string | null; errorMessage: string | null;
projectName: string; projectName: string;
projectCode: string;
createdAt: string; createdAt: string;
builtAt: string | null; builtAt: string | null;
uploadUrl: string | null;
uploadedAt: string | null;
uploadedByName: string | null;
sharedWith: string | null;
sharedNote: string | null;
deliveredAt: string | null; deliveredAt: string | null;
deliveredByName: string | null;
itemCount: number; itemCount: number;
verifiedCount: number; verifiedCount: number;
exrFileCount: number;
movCount: number;
totalBytes: number;
items: { items: {
id: string; id: string;
shotCode: string; shotCode: string;
clientCode: string | null;
versionString: string; versionString: string;
status: string; status: string;
fileCount: number | null; fileCount: number | null;
@@ -68,6 +83,7 @@ export function DeliveriesClient({ canBuild }: { canBuild: boolean }) {
const [projectId, setProjectId] = useState<string>(""); const [projectId, setProjectId] = useState<string>("");
const [episode, setEpisode] = useState<string>(""); const [episode, setEpisode] = useState<string>("");
const [building, setBuilding] = useState(false); const [building, setBuilding] = useState(false);
const [handoff, setHandoff] = useState<{ step: "upload" | "share"; packageId: string } | null>(null);
const { data: projects } = useQuery({ const { data: projects } = useQuery({
queryKey: ["pipeline-projects"], queryKey: ["pipeline-projects"],
@@ -125,21 +141,28 @@ export function DeliveriesClient({ canBuild }: { canBuild: boolean }) {
} }
} }
async function packageAction(id: string, verb: "delivered" | "cancel") { function refreshPackages() {
const res = await fetch(`/api/deliveries/${id}/${verb}`, { method: "POST" });
const body = await res.json().catch(() => ({}));
if (!res.ok) {
toast({ title: `${verb} failed`, description: body.error ?? res.statusText, variant: "destructive" });
}
queryClient.invalidateQueries({ queryKey: ["delivery-packages"] }); queryClient.invalidateQueries({ queryKey: ["delivery-packages"] });
queryClient.invalidateQueries({ queryKey: ["delivery-ready"] }); queryClient.invalidateQueries({ queryKey: ["delivery-ready"] });
} }
async function cancelPackage(id: string) {
const res = await fetch(`/api/deliveries/${id}/cancel`, { method: "POST" });
const body = await res.json().catch(() => ({}));
if (!res.ok) {
toast({ title: "Cancel failed", description: body.error ?? res.statusText, variant: "destructive" });
}
refreshPackages();
}
// Looked up from the live list so the dialog never acts on a stale row.
const handoffPackage = handoff ? packages?.packages.find((p) => p.id === handoff.packageId) : undefined;
const episodes = ready?.episodes ?? []; const episodes = ready?.episodes ?? [];
const shown = episode ? episodes.filter((e) => e.episode === episode) : episodes; const shown = episode ? episodes.filter((e) => e.episode === episode) : episodes;
return ( return (
<div className="p-6 space-y-6 max-w-6xl"> <div className="p-4 md:p-6 space-y-6 max-w-6xl">
<div className="flex items-center gap-3"> <div className="flex items-center gap-3">
<Link href="/pipeline"> <Link href="/pipeline">
<Button variant="ghost" size="icon-sm"> <Button variant="ghost" size="icon-sm">
@@ -182,6 +205,8 @@ export function DeliveriesClient({ canBuild }: { canBuild: boolean }) {
)} )}
</div> </div>
<RequestsPanel projectId={projectId} canBuild={canBuild} />
{/* Ready to build */} {/* Ready to build */}
{projectId && ( {projectId && (
<div className="rounded-lg border border-zinc-800 bg-zinc-900/40"> <div className="rounded-lg border border-zinc-800 bg-zinc-900/40">
@@ -237,18 +262,31 @@ export function DeliveriesClient({ canBuild }: { canBuild: boolean }) {
<div className="rounded-lg border border-zinc-800 bg-zinc-900/40"> <div className="rounded-lg border border-zinc-800 bg-zinc-900/40">
<div className="px-4 py-2.5 border-b border-zinc-800 text-sm font-medium text-white">Packages</div> <div className="px-4 py-2.5 border-b border-zinc-800 text-sm font-medium text-white">Packages</div>
<div className="divide-y divide-zinc-800/60"> <div className="divide-y divide-zinc-800/60">
{(packages?.packages ?? []).map((p) => ( {(packages?.packages ?? []).map((p) => {
const stage = handoffStage(p);
return (
<details key={p.id} className="group"> <details key={p.id} className="group">
<summary className="flex items-center gap-3 px-4 py-3 cursor-pointer hover:bg-zinc-900/60 flex-wrap"> <summary className="flex items-center gap-3 px-4 py-3 cursor-pointer hover:bg-zinc-900/60 flex-wrap">
<span className="text-sm text-white font-medium">#{p.packageNumber}</span> <span className="text-sm text-white font-medium">#{p.packageNumber}</span>
<span className="text-sm text-zinc-300">{p.name}</span> <span className="text-sm text-zinc-300">{p.name}</span>
{p.kind === "MOV_REVIEW" && (
<span className="rounded-full border border-violet-500/30 bg-violet-500/10 px-2 py-0.5 text-xs text-violet-300">
MOV review
</span>
)}
<span <span
className={cn( className={cn(
"rounded-full border px-2 py-0.5 text-xs", "rounded-full border px-2 py-0.5 text-xs",
DELIVERY_STATUS_STYLES[p.status] ?? "" // Built is not delivered: a package still owed to the
// client must not read as a green "READY".
stage ? "bg-amber-500/15 text-amber-400 border-amber-500/30" : (DELIVERY_STATUS_STYLES[p.status] ?? "")
)} )}
> >
{statusLabel(p.status)} {stage === "AWAITING_UPLOAD"
? "BUILT — NOT UPLOADED"
: stage === "AWAITING_SHARE"
? "UPLOADED — LINK NOT SHARED"
: statusLabel(p.status)}
</span> </span>
<span className="text-xs text-zinc-500"> <span className="text-xs text-zinc-500">
{p.episode ? `episode ${p.episode} · ` : ""} {p.episode ? `episode ${p.episode} · ` : ""}
@@ -257,17 +295,30 @@ export function DeliveriesClient({ canBuild }: { canBuild: boolean }) {
<span className="text-xs text-zinc-600">{new Date(p.createdAt).toLocaleDateString()}</span> <span className="text-xs text-zinc-600">{new Date(p.createdAt).toLocaleDateString()}</span>
{p.status === "BUILDING" && <RefreshCw className="h-3.5 w-3.5 text-blue-400 animate-spin" />} {p.status === "BUILDING" && <RefreshCw className="h-3.5 w-3.5 text-blue-400 animate-spin" />}
<span className="ml-auto flex items-center gap-2"> <span className="ml-auto flex items-center gap-2">
{canBuild && p.status === "READY" && ( {canBuild && stage === "AWAITING_UPLOAD" && (
<Button <Button
size="sm" size="sm"
variant="outline" variant="outline"
onClick={(e) => { onClick={(e) => {
e.preventDefault(); e.preventDefault();
packageAction(p.id, "delivered"); setHandoff({ step: "upload", packageId: p.id });
}}
>
<Upload className="h-4 w-4 mr-2 text-amber-400" />
Record upload
</Button>
)}
{canBuild && stage === "AWAITING_SHARE" && (
<Button
size="sm"
variant="outline"
onClick={(e) => {
e.preventDefault();
setHandoff({ step: "share", packageId: p.id });
}} }}
> >
<CheckCircle2 className="h-4 w-4 mr-2 text-emerald-400" /> <CheckCircle2 className="h-4 w-4 mr-2 text-emerald-400" />
Mark delivered Share link
</Button> </Button>
)} )}
{canBuild && ["QUEUED", "FAILED", "DRAFT"].includes(p.status) && ( {canBuild && ["QUEUED", "FAILED", "DRAFT"].includes(p.status) && (
@@ -276,7 +327,7 @@ export function DeliveriesClient({ canBuild }: { canBuild: boolean }) {
variant="outline" variant="outline"
onClick={(e) => { onClick={(e) => {
e.preventDefault(); e.preventDefault();
packageAction(p.id, "cancel"); cancelPackage(p.id);
}} }}
> >
<XCircle className="h-4 w-4 mr-2 text-red-400" /> <XCircle className="h-4 w-4 mr-2 text-red-400" />
@@ -288,9 +339,31 @@ export function DeliveriesClient({ canBuild }: { canBuild: boolean }) {
<div className="px-4 pb-4 space-y-2"> <div className="px-4 pb-4 space-y-2">
{p.rootPath && <div className="text-xs text-zinc-500 break-all">{p.rootPath}</div>} {p.rootPath && <div className="text-xs text-zinc-500 break-all">{p.rootPath}</div>}
{p.errorMessage && <div className="text-xs text-red-400">{p.errorMessage}</div>} {p.errorMessage && <div className="text-xs text-red-400">{p.errorMessage}</div>}
{p.uploadedAt && p.uploadUrl && (
<div className="text-xs text-zinc-400 break-all">
Uploaded {new Date(p.uploadedAt).toLocaleString()}
{p.uploadedByName ? ` by ${p.uploadedByName}` : ""} —{" "}
<a href={p.uploadUrl} target="_blank" rel="noreferrer" className="text-sky-400 hover:underline">
{p.uploadUrl}
</a>
{canBuild && stage === "AWAITING_SHARE" && (
<button
type="button"
className="ml-2 text-zinc-500 hover:text-white underline"
onClick={() => setHandoff({ step: "upload", packageId: p.id })}
>
change
</button>
)}
</div>
)}
{p.deliveredAt && ( {p.deliveredAt && (
<div className="text-xs text-emerald-400"> <div className="text-xs text-emerald-400">
Delivered {new Date(p.deliveredAt).toLocaleString()} {p.sharedWith
? `Link shared with ${p.sharedWith} ${new Date(p.deliveredAt).toLocaleString()}`
: `Delivered ${new Date(p.deliveredAt).toLocaleString()} — before uploads and shares were recorded`}
{p.deliveredByName ? ` by ${p.deliveredByName}` : ""}
{p.sharedNote ? ` — ${p.sharedNote}` : ""}
</div> </div>
)} )}
<div className="grid sm:grid-cols-2 lg:grid-cols-3 gap-x-6 gap-y-1"> <div className="grid sm:grid-cols-2 lg:grid-cols-3 gap-x-6 gap-y-1">
@@ -309,7 +382,9 @@ export function DeliveriesClient({ canBuild }: { canBuild: boolean }) {
</span> </span>
<span className="text-zinc-300">{item.shotCode}</span> <span className="text-zinc-300">{item.shotCode}</span>
<span className="text-zinc-500">{item.versionString}</span> <span className="text-zinc-500">{item.versionString}</span>
{item.fileCount != null && <span className="text-zinc-600">{item.fileCount}f</span>} {p.kind === "EXR_DELIVERY" && item.fileCount != null && (
<span className="text-zinc-600">{item.fileCount}f</span>
)}
{item.linkMode && <span className="text-zinc-600">{item.linkMode}</span>} {item.linkMode && <span className="text-zinc-600">{item.linkMode}</span>}
{item.errorMessage && <span className="text-red-400">{item.errorMessage}</span>} {item.errorMessage && <span className="text-red-400">{item.errorMessage}</span>}
</div> </div>
@@ -317,12 +392,24 @@ export function DeliveriesClient({ canBuild }: { canBuild: boolean }) {
</div> </div>
</div> </div>
</details> </details>
))} );
})}
{(packages?.packages ?? []).length === 0 && ( {(packages?.packages ?? []).length === 0 && (
<div className="p-4 text-sm text-zinc-500">No packages built yet</div> <div className="p-4 text-sm text-zinc-500">No packages built yet</div>
)} )}
</div> </div>
</div> </div>
{handoff?.step === "upload" && handoffPackage && (
<RecordUploadDialog pkg={handoffPackage} onClose={() => setHandoff(null)} onSaved={refreshPackages} />
)}
{handoff?.step === "share" && handoffPackage?.uploadUrl && (
<RecordShareDialog
pkg={{ ...handoffPackage, uploadUrl: handoffPackage.uploadUrl }}
onClose={() => setHandoff(null)}
onSaved={refreshPackages}
/>
)}
</div> </div>
); );
} }
@@ -0,0 +1,218 @@
"use client";
import { useState } from "react";
import { Copy } from "lucide-react";
import { Button } from "@/components/ui/button";
import { Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
import { Input } from "@/components/ui/input";
import { Label } from "@/components/ui/label";
import { Textarea } from "@/components/ui/textarea";
import { useToast } from "@/components/ui/use-toast";
import { buildShareMessage } from "@/lib/render-pipeline/delivery-handoff";
export interface HandoffPackage {
id: string;
packageNumber: number;
name: string;
projectCode: string;
episode: string;
rootPath: string | null;
uploadUrl: string | null;
itemCount: number;
exrFileCount: number;
movCount: number;
totalBytes: number;
items: { shotCode: string; clientCode: string | null; versionString: string }[];
}
function formatSize(bytes: number): string {
if (!bytes) return "size unknown";
const gb = bytes / 1_073_741_824;
return gb >= 1 ? `${gb.toFixed(1)} GB` : `${(bytes / 1_048_576).toFixed(0)} MB`;
}
async function post(path: string, body: unknown): Promise<string | null> {
const res = await fetch(path, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify(body),
});
if (res.ok) return null;
const data = await res.json().catch(() => ({}));
return data.error ?? res.statusText;
}
/** Step one: where the folder now lives on the client's side. */
export function RecordUploadDialog({
pkg,
onClose,
onSaved,
}: {
pkg: HandoffPackage;
onClose: () => void;
onSaved: () => void;
}) {
const { toast } = useToast();
const [uploadUrl, setUploadUrl] = useState(pkg.uploadUrl ?? "");
const [confirmed, setConfirmed] = useState(false);
const [saving, setSaving] = useState(false);
async function save() {
setSaving(true);
const error = await post(`/api/deliveries/${pkg.id}/uploaded`, { uploadUrl, contentsConfirmed: confirmed });
setSaving(false);
if (error) {
toast({ title: "Upload not recorded", description: error, variant: "destructive" });
return;
}
onSaved();
onClose();
}
return (
<Dialog open onOpenChange={(open) => !open && onClose()}>
<DialogContent>
<DialogHeader>
<DialogTitle>
Record upload — #{pkg.packageNumber} {pkg.name}
</DialogTitle>
<DialogDescription>
Paste the link to the folder on the client&apos;s portal. The package stays on the dashboard as
awaiting delivery until the link has also been shared.
</DialogDescription>
</DialogHeader>
<div className="space-y-4">
<div className="rounded-md border border-zinc-800 bg-zinc-900/60 p-3 text-xs text-zinc-400 space-y-1">
<div className="text-zinc-200">
The upload should contain {pkg.itemCount} shot{pkg.itemCount === 1 ? "" : "s"} · {pkg.exrFileCount} EXR
frames · {pkg.movCount} MOV{pkg.movCount === 1 ? "" : "s"} · {formatSize(pkg.totalBytes)}
</div>
{pkg.rootPath && <div className="break-all">Source: {pkg.rootPath}</div>}
</div>
<div className="space-y-1.5">
<Label htmlFor="upload-url">Upload link</Label>
<Input
id="upload-url"
type="url"
placeholder="https://…"
value={uploadUrl}
onChange={(e) => setUploadUrl(e.target.value)}
autoFocus
/>
</div>
<label className="flex items-start gap-2 text-sm text-zinc-300">
<input
type="checkbox"
className="mt-1"
checked={confirmed}
onChange={(e) => setConfirmed(e.target.checked)}
/>
<span>I opened this link and the upload has finished and matches the counts above.</span>
</label>
</div>
<DialogFooter>
<Button variant="outline" onClick={onClose}>
Cancel
</Button>
<Button onClick={save} disabled={saving || !uploadUrl.trim() || !confirmed}>
Record upload
</Button>
</DialogFooter>
</DialogContent>
</Dialog>
);
}
/** Step two: the link went to a person. This is what makes it delivered. */
export function RecordShareDialog({
pkg,
onClose,
onSaved,
}: {
pkg: HandoffPackage & { uploadUrl: string };
onClose: () => void;
onSaved: () => void;
}) {
const { toast } = useToast();
const [sharedWith, setSharedWith] = useState("");
const [note, setNote] = useState("");
const [saving, setSaving] = useState(false);
const message = buildShareMessage(pkg);
async function copy() {
try {
await navigator.clipboard.writeText(message);
toast({ title: "Message copied" });
} catch {
toast({ title: "Could not copy", description: "Select the text and copy it by hand.", variant: "destructive" });
}
}
async function save() {
setSaving(true);
const error = await post(`/api/deliveries/${pkg.id}/delivered`, { sharedWith, note: note || null });
setSaving(false);
if (error) {
toast({ title: "Not marked delivered", description: error, variant: "destructive" });
return;
}
onSaved();
onClose();
}
return (
<Dialog open onOpenChange={(open) => !open && onClose()}>
<DialogContent>
<DialogHeader>
<DialogTitle>
Share link — #{pkg.packageNumber} {pkg.name}
</DialogTitle>
<DialogDescription>
Send this message to the client, then record who it went to. That marks the package delivered.
</DialogDescription>
</DialogHeader>
<div className="space-y-4">
<div className="space-y-1.5">
<div className="flex items-center justify-between">
<Label htmlFor="share-message">Message</Label>
<Button size="sm" variant="outline" onClick={copy}>
<Copy className="h-3.5 w-3.5 mr-2" />
Copy message
</Button>
</div>
<Textarea id="share-message" readOnly value={message} rows={8} className="font-mono text-xs" />
</div>
<div className="space-y-1.5">
<Label htmlFor="shared-with">Sent to</Label>
<Input
id="shared-with"
placeholder="Name, and where — e.g. Sam, production WhatsApp group"
value={sharedWith}
onChange={(e) => setSharedWith(e.target.value)}
/>
</div>
<div className="space-y-1.5">
<Label htmlFor="share-note">Note (optional)</Label>
<Input id="share-note" value={note} onChange={(e) => setNote(e.target.value)} />
</div>
</div>
<DialogFooter>
<Button variant="outline" onClick={onClose}>
Cancel
</Button>
<Button onClick={save} disabled={saving || !sharedWith.trim()}>
Link sent — mark delivered
</Button>
</DialogFooter>
</DialogContent>
</Dialog>
);
}
@@ -0,0 +1,273 @@
"use client";
import { useState } from "react";
import { useQuery, useQueryClient } from "@tanstack/react-query";
import { Package, Plus, XCircle } from "lucide-react";
import { Button } from "@/components/ui/button";
import { Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
import { Input } from "@/components/ui/input";
import { useToast } from "@/components/ui/use-toast";
import { cn } from "@/lib/utils";
import { LogRequestDialog } from "@/components/delivery/LogRequestDialog";
import {
DELIVERABLE_LABEL,
LINE_STAGE_LABEL,
type Deliverable,
type RequestLineStage,
} from "@/lib/render-pipeline/delivery-request-state";
interface RequestRow {
id: string;
requestNumber: number;
projectId: string;
projectCode: string;
episode: string;
deliverable: string;
requestedBy: string;
note: string | null;
dueDate: string | null;
createdAt: string;
cancelReason: string | null;
state: "OPEN" | "CLOSED" | "CANCELLED";
lineCount: number;
deliveredCount: number;
severity: "normal" | "warning" | "critical";
lines: {
id: string;
shotCode: string;
clientCode: string | null;
stage: RequestLineStage;
readyExportId: string | null;
}[];
}
const SEVERITY_STYLES: Record<RequestRow["severity"], string> = {
normal: "bg-zinc-500/15 text-zinc-300 border-zinc-500/30",
warning: "bg-amber-500/15 text-amber-400 border-amber-500/30",
critical: "bg-red-500/15 text-red-400 border-red-500/30",
};
const STAGE_STYLES: Record<RequestLineStage, string> = {
DELIVERED: "text-emerald-400",
UPLOADED: "text-amber-400",
BUILT: "text-amber-400",
BUILDING: "text-blue-400",
READY: "text-green-400",
IN_QC: "text-zinc-400",
NOT_READY: "text-zinc-500",
};
function requestTitle(r: RequestRow): string {
const what = DELIVERABLE_LABEL[r.deliverable as Deliverable] ?? r.deliverable;
return r.episode ? `${what} for ${r.episode}` : `${what} · ${r.lineCount} shot${r.lineCount === 1 ? "" : "s"}`;
}
/**
* What clients have asked for. An open request lists every shot with where it
* stands, so "did 116 go out?" is answered by the page rather than by memory.
*/
export function RequestsPanel({ projectId, canBuild }: { projectId: string; canBuild: boolean }) {
const { toast } = useToast();
const queryClient = useQueryClient();
const [logging, setLogging] = useState(false);
const [cancelling, setCancelling] = useState<RequestRow | null>(null);
const [reason, setReason] = useState("");
const [busy, setBusy] = useState(false);
const { data } = useQuery({
queryKey: ["delivery-requests", projectId],
queryFn: async () => {
const res = await fetch(`/api/delivery-requests${projectId ? `?projectId=${encodeURIComponent(projectId)}` : ""}`);
if (!res.ok) throw new Error("Failed to load delivery requests");
return res.json() as Promise<{ requests: RequestRow[] }>;
},
// Lines move as packages build and get shared on this same page.
refetchInterval: 5000,
});
const refresh = () => {
queryClient.invalidateQueries({ queryKey: ["delivery-requests"] });
queryClient.invalidateQueries({ queryKey: ["delivery-packages"] });
queryClient.invalidateQueries({ queryKey: ["delivery-ready"] });
};
async function build(request: RequestRow) {
const exportIds = request.lines.flatMap((l) => (l.readyExportId ? [l.readyExportId] : []));
if (!exportIds.length) return;
setBusy(true);
const res = await fetch("/api/deliveries", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ projectId: request.projectId, episode: request.episode || null, exportIds }),
});
const body = await res.json().catch(() => ({}));
setBusy(false);
if (!res.ok) {
toast({ title: "Build failed", description: body.error ?? res.statusText, variant: "destructive" });
} else {
toast({
title: `Package #${body.package.packageNumber} queued`,
description: `${body.package.itemCount} shots for request #${request.requestNumber}`,
});
}
refresh();
}
async function cancel() {
if (!cancelling) return;
setBusy(true);
const res = await fetch(`/api/delivery-requests/${cancelling.id}/cancel`, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ reason }),
});
const body = await res.json().catch(() => ({}));
setBusy(false);
if (!res.ok) {
toast({ title: "Not cancelled", description: body.error ?? res.statusText, variant: "destructive" });
return;
}
setCancelling(null);
refresh();
}
const requests = data?.requests ?? [];
const open = requests.filter((r) => r.state === "OPEN");
const past = requests.filter((r) => r.state !== "OPEN");
return (
<div className="rounded-lg border border-zinc-800 bg-zinc-900/40">
<div className="flex items-center justify-between gap-3 px-4 py-2.5 border-b border-zinc-800">
<span className="text-sm font-medium text-white">Delivery requests</span>
{canBuild && (
<Button size="sm" variant="outline" onClick={() => setLogging(true)}>
<Plus className="h-3.5 w-3.5 mr-1.5" />
Log request
</Button>
)}
</div>
{open.length === 0 && <div className="p-4 text-sm text-zinc-500">No open requests.</div>}
<div className="divide-y divide-zinc-800/60">
{open.map((r) => {
const readyCount = r.lines.filter((l) => l.readyExportId).length;
return (
<details key={r.id} open className="group">
<summary className="flex items-center gap-3 px-4 py-3 cursor-pointer hover:bg-zinc-900/60 flex-wrap">
<span className="text-sm text-white font-medium">Request #{r.requestNumber}</span>
<span className="text-sm text-zinc-300">{requestTitle(r)}</span>
<span className={cn("rounded-full border px-2 py-0.5 text-xs", SEVERITY_STYLES[r.severity])}>
{r.deliveredCount} of {r.lineCount} delivered
</span>
<span className="text-xs text-zinc-500">
{r.projectCode} · asked by {r.requestedBy} · {new Date(r.createdAt).toLocaleDateString()}
{r.dueDate ? ` · due ${new Date(r.dueDate).toLocaleDateString()}` : ""}
</span>
<span className="ml-auto flex items-center gap-2">
{canBuild && readyCount > 0 && (
<Button
size="sm"
disabled={busy}
onClick={(e) => {
e.preventDefault();
build(r);
}}
>
<Package className="h-4 w-4 mr-2" />
Build {readyCount} ready
</Button>
)}
{canBuild && (
<Button
size="sm"
variant="outline"
onClick={(e) => {
e.preventDefault();
setReason("");
setCancelling(r);
}}
>
<XCircle className="h-4 w-4 mr-2 text-red-400" />
Cancel request
</Button>
)}
</span>
</summary>
<div className="px-4 pb-4 space-y-2">
{r.note && <div className="text-xs text-zinc-400">{r.note}</div>}
<div className="grid sm:grid-cols-2 lg:grid-cols-3 gap-x-6 gap-y-1">
{r.lines.map((line) => (
<div key={line.id} className="flex items-center gap-2 text-xs">
<span className="text-zinc-300">{line.shotCode}</span>
{line.clientCode && <span className="text-zinc-600">{line.clientCode}</span>}
<span className={STAGE_STYLES[line.stage]}>{LINE_STAGE_LABEL[line.stage]}</span>
</div>
))}
</div>
</div>
</details>
);
})}
</div>
{past.length > 0 && (
<details className="border-t border-zinc-800">
<summary className="px-4 py-2.5 cursor-pointer text-xs text-zinc-500 hover:text-zinc-300">
Closed and cancelled ({past.length})
</summary>
<div className="px-4 pb-3 space-y-1">
{past.map((r) => (
<div key={r.id} className="text-xs text-zinc-500">
<span className="text-zinc-300">Request #{r.requestNumber}</span> {requestTitle(r)} · {r.projectCode} ·
asked by {r.requestedBy} ·{" "}
{r.state === "CANCELLED" ? (
<span className="text-zinc-400">cancelled — {r.cancelReason}</span>
) : (
<span className="text-emerald-400">all {r.lineCount} delivered</span>
)}
</div>
))}
</div>
</details>
)}
<LogRequestDialog
open={logging}
onClose={() => setLogging(false)}
onLogged={refresh}
defaultProjectId={projectId || undefined}
/>
{cancelling && (
<Dialog open onOpenChange={(o) => !o && !busy && setCancelling(null)}>
<DialogContent>
<DialogHeader>
<DialogTitle>Cancel request #{cancelling.requestNumber}</DialogTitle>
<DialogDescription>
{cancelling.lineCount - cancelling.deliveredCount} of {cancelling.lineCount} shots have not been
delivered. Cancelling removes the request from Awaiting delivery; it stays in the history with the
reason.
</DialogDescription>
</DialogHeader>
<Input
aria-label="Reason"
placeholder="Why — e.g. client no longer needs 116"
value={reason}
onChange={(e) => setReason(e.target.value)}
autoFocus
/>
<DialogFooter>
<Button variant="outline" onClick={() => setCancelling(null)} disabled={busy}>
Keep request
</Button>
<Button variant="destructive" onClick={cancel} disabled={busy || !reason.trim()}>
Cancel request
</Button>
</DialogFooter>
</DialogContent>
</Dialog>
)}
</div>
);
}
@@ -155,10 +155,10 @@ export function ExportDetailClient({ exportId }: { exportId: string }) {
} }
} }
if (isLoading) return <div className="p-6 text-zinc-500">Loading…</div>; if (isLoading) return <div className="p-4 md:p-6 text-zinc-500">Loading…</div>;
if (error || !data) { if (error || !data) {
return ( return (
<div className="p-6 text-red-400"> <div className="p-4 md:p-6 text-red-400">
{(error as Error)?.message ?? "Export not found"} {(error as Error)?.message ?? "Export not found"}
</div> </div>
); );
@@ -180,7 +180,7 @@ export function ExportDetailClient({ exportId }: { exportId: string }) {
]; ];
return ( return (
<div className="p-6 space-y-6 max-w-5xl"> <div className="p-4 md:p-6 space-y-6 max-w-5xl">
<div className="flex items-center justify-between gap-4 flex-wrap"> <div className="flex items-center justify-between gap-4 flex-wrap">
<div className="flex items-center gap-3"> <div className="flex items-center gap-3">
<Link href="/pipeline"> <Link href="/pipeline">
@@ -76,7 +76,7 @@ export function MachinesClient() {
const machines = data?.machines ?? []; const machines = data?.machines ?? [];
return ( return (
<div className="p-6 space-y-6"> <div className="p-4 md:p-6 space-y-6">
<div className="flex items-center gap-3"> <div className="flex items-center gap-3">
<Link href="/pipeline"> <Link href="/pipeline">
<Button variant="ghost" size="icon-sm"> <Button variant="ghost" size="icon-sm">
+14 -2
View File
@@ -1,20 +1,32 @@
import { auth } from "@/auth"; import { auth } from "@/auth";
import { redirect } from "next/navigation"; import { redirect } from "next/navigation";
import { ExportStatus } from "@prisma/client";
import { db } from "@/lib/db"; import { db } from "@/lib/db";
import { PipelineQueueClient } from "./PipelineQueueClient"; import { PipelineQueueClient } from "./PipelineQueueClient";
export const dynamic = "force-dynamic"; export const dynamic = "force-dynamic";
export default async function PipelinePage() { export default async function PipelinePage({
searchParams,
}: {
searchParams: Promise<{ status?: string }>;
}) {
const session = await auth(); const session = await auth();
if (!session?.user) redirect("/login"); if (!session?.user) redirect("/login");
if (session.user.role === "CLIENT") redirect("/dashboard"); if (session.user.role === "CLIENT") redirect("/dashboard");
// Lets other pages link straight to a filtered queue — the dashboard's "In
// QC" figure is only useful if it leads to the rows it counted. Anything
// that is not a real status falls back to the unfiltered queue.
const requested = (await searchParams).status;
const initialStatus =
requested && (Object.values(ExportStatus) as string[]).includes(requested) ? requested : "all";
const projects = await db.project.findMany({ const projects = await db.project.findMany({
where: { status: { in: ["ACTIVE", "ON_HOLD"] } }, where: { status: { in: ["ACTIVE", "ON_HOLD"] } },
select: { id: true, name: true, code: true }, select: { id: true, name: true, code: true },
orderBy: { name: "asc" }, orderBy: { name: "asc" },
}); });
return <PipelineQueueClient projects={projects} />; return <PipelineQueueClient projects={projects} initialStatus={initialStatus} />;
} }
+196 -8
View File
@@ -1,9 +1,10 @@
"use client"; "use client";
import { useState, useEffect, useRef, useCallback } from "react"; import { useState, useEffect, useRef, useCallback, useMemo, startTransition } from "react";
import Image from "next/image"; import Image from "next/image";
import Link from "next/link"; import Link from "next/link";
import { ReviewPlayer, type ReviewPlayerRef } from "@/components/player/ReviewPlayer"; import { ReviewPlayer, type ReviewPlayerRef } from "@/components/player/ReviewPlayer";
import { SequencePlayer, type SequenceClip } from "@/components/player/SequencePlayer";
import { useReviewStore } from "@/hooks/use-review-player"; import { useReviewStore } from "@/hooks/use-review-player";
import { import {
Select, Select,
@@ -26,6 +27,8 @@ import {
ExternalLink, ExternalLink,
ShieldCheck, ShieldCheck,
Send, Send,
ListVideo,
X,
} from "lucide-react"; } from "lucide-react";
interface Project { interface Project {
@@ -42,6 +45,12 @@ interface PlaylistVersion {
thumbnailUrl: string | null; thumbnailUrl: string | null;
posterUrl: string | null; posterUrl: string | null;
fps: number; fps: number;
duration?: number | null;
frameCount?: number | null;
hqFileUrl?: string | null;
handleHead?: number | null;
handleTail?: number | null;
pictureStartFrame?: number | null;
approvalStatus: string; approvalStatus: string;
taskTitle: string; taskTitle: string;
} }
@@ -86,6 +95,10 @@ export function PlaylistClient({ projects, userRole }: PlaylistClientProps) {
const [activeShot, setActiveShot] = useState<PlaylistShot | null>(null); const [activeShot, setActiveShot] = useState<PlaylistShot | null>(null);
const [isLoading, setIsLoading] = useState(false); const [isLoading, setIsLoading] = useState(false);
const [isActioning, setIsActioning] = useState(false); const [isActioning, setIsActioning] = useState(false);
/** Shots checked for the seamless playlist, by shot id. */
const [selected, setSelected] = useState<Set<string>>(new Set());
const [sequenceMode, setSequenceMode] = useState(false);
const lastChecked = useRef<string | null>(null);
const canApprove = ["ADMIN", "PRODUCER", "SUPERVISOR"].includes(userRole); const canApprove = ["ADMIN", "PRODUCER", "SUPERVISOR"].includes(userRole);
@@ -112,6 +125,9 @@ export function PlaylistClient({ projects, userRole }: PlaylistClientProps) {
if (cancelled) return; if (cancelled) return;
const list: PlaylistShot[] = data.shots ?? []; const list: PlaylistShot[] = data.shots ?? [];
setShots(list); setShots(list);
setSelected(loadSelection(projectId, list));
lastChecked.current = null;
setSequenceMode(false);
// Auto-select the first shot, or keep the current one if it still exists // Auto-select the first shot, or keep the current one if it still exists
setActiveShot((prev) => { setActiveShot((prev) => {
const stillExists = prev && list.some((s) => s.id === prev.id); const stillExists = prev && list.some((s) => s.id === prev.id);
@@ -134,9 +150,78 @@ export function PlaylistClient({ projects, userRole }: PlaylistClientProps) {
const handleSelectShot = useCallback((shot: PlaylistShot) => { const handleSelectShot = useCallback((shot: PlaylistShot) => {
reset(); reset();
setSequenceMode(false);
setActiveShot(shot); setActiveShot(shot);
}, [reset]); }, [reset]);
const updateSelection = useCallback(
(next: Set<string>) => {
setSelected(next);
if (projectId) saveSelection(projectId, next);
if (next.size === 0) setSequenceMode(false);
},
[projectId]
);
/** Toggle one shot; shift-click sets every shot between it and the last one checked. */
const toggleChecked = (shot: PlaylistShot, shift: boolean) => {
const next = new Set(selected);
const on = !selected.has(shot.id);
const from = lastChecked.current ? shots.findIndex((s) => s.id === lastChecked.current) : -1;
const to = shots.findIndex((s) => s.id === shot.id);
const range = shift && from >= 0 ? shots.slice(Math.min(from, to), Math.max(from, to) + 1) : [shot];
for (const s of range) {
if (on) next.add(s.id);
else next.delete(s.id);
}
lastChecked.current = shot.id;
updateSelection(next);
};
const setGroupChecked = (group: PlaylistShot[], on: boolean) => {
const next = new Set(selected);
for (const s of group) {
if (on) next.add(s.id);
else next.delete(s.id);
}
updateSelection(next);
};
// The playlist, in edit order. Keyed on the versions it plays so a refresh
// (e.g. after approving a shot) doesn't restart playback.
const clipKey = shots
.filter((s) => selected.has(s.id))
.map((s) => s.latestVersion.id)
.join(",");
const clips = useMemo<SequenceClip[]>(
() =>
shots
.filter((s) => selected.has(s.id))
.map((s) => ({
id: s.latestVersion.id,
label: s.shotCode,
sublabel: `v${String(s.latestVersion.versionNumber).padStart(3, "0")}`,
url: s.latestVersion.fileUrl,
hqUrl: s.latestVersion.hqFileUrl,
fps: s.latestVersion.fps,
duration: s.latestVersion.duration,
handles: s.latestVersion,
})),
// eslint-disable-next-line react-hooks/exhaustive-deps
[clipKey]
);
const handleClipChange = useCallback(
(clip: SequenceClip) => {
// A transition, so re-rendering the page (shot list and all) yields to
// the video: rendered in one go, it dropped the frame after every cut.
startTransition(() => {
setActiveShot(shots.find((s) => s.latestVersion.id === clip.id) ?? null);
});
},
[shots]
);
const refreshShots = useCallback(() => { const refreshShots = useCallback(() => {
if (!projectId) return; if (!projectId) return;
fetch(`/api/playlist?projectId=${projectId}`) fetch(`/api/playlist?projectId=${projectId}`)
@@ -215,6 +300,33 @@ export function PlaylistClient({ projects, userRole }: PlaylistClientProps) {
</Select> </Select>
</div> </div>
{selected.size > 0 && (
sequenceMode ? (
<Button
size="sm"
variant="outline"
onClick={() => setSequenceMode(false)}
className="h-7 text-xs gap-1"
>
<X className="h-3 w-3" />
Exit playlist
</Button>
) : (
<Button
size="sm"
onClick={() => {
reset();
setSequenceMode(true);
}}
className="h-7 text-xs gap-1"
title="Play the checked shots back to back: cut only, no slate or handles"
>
<ListVideo className="h-3.5 w-3.5" />
Play selection ({selected.size})
</Button>
)
)}
{activeShot && ( {activeShot && (
<div className="flex items-center gap-2 ml-auto"> <div className="flex items-center gap-2 ml-auto">
<span className="font-mono text-sm text-white">{activeShot.shotCode}</span> <span className="font-mono text-sm text-white">{activeShot.shotCode}</span>
@@ -267,7 +379,9 @@ export function PlaylistClient({ projects, userRole }: PlaylistClientProps) {
<div className="flex flex-1 min-h-0 overflow-hidden"> <div className="flex flex-1 min-h-0 overflow-hidden">
{/* Player */} {/* Player */}
<div className="flex-1 min-w-0 bg-black flex flex-col"> <div className="flex-1 min-w-0 bg-black flex flex-col">
{activeShot ? ( {sequenceMode && clips.length > 0 ? (
<SequencePlayer clips={clips} onClipChange={handleClipChange} />
) : activeShot ? (
<ReviewPlayer <ReviewPlayer
key={activeShot.latestVersion.id} key={activeShot.latestVersion.id}
ref={playerRef} ref={playerRef}
@@ -276,6 +390,8 @@ export function PlaylistClient({ projects, userRole }: PlaylistClientProps) {
fps={activeShot.latestVersion.fps} fps={activeShot.latestVersion.fps}
comments={[]} comments={[]}
annotations={[]} annotations={[]}
handles={activeShot.latestVersion}
hqVideoUrl={activeShot.latestVersion.hqFileUrl}
/> />
) : ( ) : (
<div className="flex-1 flex flex-col items-center justify-center gap-3 text-zinc-600"> <div className="flex-1 flex flex-col items-center justify-center gap-3 text-zinc-600">
@@ -297,7 +413,26 @@ export function PlaylistClient({ projects, userRole }: PlaylistClientProps) {
<div className="px-3 py-2.5 border-b border-border shrink-0 flex items-center justify-between"> <div className="px-3 py-2.5 border-b border-border shrink-0 flex items-center justify-between">
<span className="text-xs font-medium text-zinc-400 uppercase tracking-wider">Shots</span> <span className="text-xs font-medium text-zinc-400 uppercase tracking-wider">Shots</span>
{shots.length > 0 && ( {shots.length > 0 && (
<span className="text-xs text-zinc-600">{shots.length}</span> <div className="flex items-center gap-2 text-xs">
{selected.size > 0 ? (
<button
onClick={() => updateSelection(new Set())}
className="text-zinc-500 hover:text-zinc-200"
>
Clear
</button>
) : (
<button
onClick={() => setGroupChecked(shots, true)}
className="text-zinc-500 hover:text-zinc-200"
>
Select all
</button>
)}
<span className="text-zinc-600">
{selected.size > 0 ? `${selected.size}/${shots.length}` : shots.length}
</span>
</div>
)} )}
</div> </div>
@@ -320,16 +455,25 @@ export function PlaylistClient({ projects, userRole }: PlaylistClientProps) {
<div> <div>
{episodeGroups.map(([episode, episodeShots]) => ( {episodeGroups.map(([episode, episodeShots]) => (
<div key={episode}> <div key={episode}>
<div className="px-3 py-1.5 bg-zinc-900/80 sticky top-0 z-10 border-b border-zinc-800"> <label className="px-3 py-1.5 bg-zinc-900/80 sticky top-0 z-10 border-b border-zinc-800 flex items-center gap-2 cursor-pointer">
<input
type="checkbox"
className="h-3 w-3 accent-blue-500 cursor-pointer"
checked={episodeShots.every((s) => selected.has(s.id))}
onChange={(e) => setGroupChecked(episodeShots, e.target.checked)}
title="Select this episode"
/>
<span className="text-[10px] font-semibold text-zinc-500 uppercase tracking-wider"> <span className="text-[10px] font-semibold text-zinc-500 uppercase tracking-wider">
Ep {episode} Ep {episode}
</span> </span>
</div> </label>
{episodeShots.map((shot) => ( {episodeShots.map((shot) => (
<ShotThumbnail <ShotThumbnail
key={shot.id} key={shot.id}
shot={shot} shot={shot}
isActive={activeShot?.id === shot.id} isActive={activeShot?.id === shot.id}
isChecked={selected.has(shot.id)}
onToggle={(shift) => toggleChecked(shot, shift)}
onClick={() => handleSelectShot(shot)} onClick={() => handleSelectShot(shot)}
/> />
))} ))}
@@ -343,6 +487,8 @@ export function PlaylistClient({ projects, userRole }: PlaylistClientProps) {
key={shot.id} key={shot.id}
shot={shot} shot={shot}
isActive={activeShot?.id === shot.id} isActive={activeShot?.id === shot.id}
isChecked={selected.has(shot.id)}
onToggle={(shift) => toggleChecked(shot, shift)}
onClick={() => handleSelectShot(shot)} onClick={() => handleSelectShot(shot)}
/> />
))} ))}
@@ -358,25 +504,45 @@ export function PlaylistClient({ projects, userRole }: PlaylistClientProps) {
function ShotThumbnail({ function ShotThumbnail({
shot, shot,
isActive, isActive,
isChecked,
onToggle,
onClick, onClick,
}: { }: {
shot: PlaylistShot; shot: PlaylistShot;
isActive: boolean; isActive: boolean;
isChecked: boolean;
onToggle: (shift: boolean) => void;
onClick: () => void; onClick: () => void;
}) { }) {
const thumb = shot.latestVersion.thumbnailUrl ?? shot.latestVersion.posterUrl ?? shot.thumbnailUrl; const thumb = shot.latestVersion.thumbnailUrl ?? shot.latestVersion.posterUrl ?? shot.thumbnailUrl;
const ApprovalIcon = APPROVAL_ICONS[shot.latestVersion.approvalStatus] ?? Clock; const ApprovalIcon = APPROVAL_ICONS[shot.latestVersion.approvalStatus] ?? Clock;
return ( return (
<button <div
role="button"
tabIndex={0}
onClick={onClick} onClick={onClick}
onKeyDown={(e) => {
if (e.key === "Enter") onClick();
}}
className={cn( className={cn(
"w-full flex items-start gap-2.5 px-3 py-2.5 text-left transition-colors border-b border-zinc-800/60 group", "w-full flex items-start gap-2.5 px-3 py-2.5 text-left transition-colors border-b border-zinc-800/60 group cursor-pointer",
isActive isActive
? "bg-blue-500/10 border-l-2 border-l-blue-500" ? "bg-blue-500/10 border-l-2 border-l-blue-500"
: "hover:bg-zinc-800/40 border-l-2 border-l-transparent" : "hover:bg-zinc-800/40 border-l-2 border-l-transparent"
)} )}
> >
<input
type="checkbox"
checked={isChecked}
onChange={() => {}}
onClick={(e) => {
e.stopPropagation();
onToggle(e.shiftKey);
}}
className="mt-3 h-3.5 w-3.5 shrink-0 accent-blue-500 cursor-pointer"
title="Add to playlist (shift-click for a range)"
/>
{/* Thumbnail */} {/* Thumbnail */}
<div className="w-20 aspect-[2.39/1] rounded overflow-hidden bg-zinc-800 shrink-0 flex items-center justify-center"> <div className="w-20 aspect-[2.39/1] rounded overflow-hidden bg-zinc-800 shrink-0 flex items-center justify-center">
{thumb ? ( {thumb ? (
@@ -408,6 +574,28 @@ function ShotThumbnail({
</span> </span>
</div> </div>
</div> </div>
</button> </div>
); );
} }
const selectionKey = (projectId: string) => `playlist:selection:${projectId}`;
/** The checked shots remembered for this project, minus any no longer listed. */
function loadSelection(projectId: string, shots: PlaylistShot[]): Set<string> {
try {
const ids: unknown = JSON.parse(localStorage.getItem(selectionKey(projectId)) ?? "[]");
if (!Array.isArray(ids)) return new Set();
const listed = new Set(shots.map((s) => s.id));
return new Set(ids.filter((id): id is string => typeof id === "string" && listed.has(id)));
} catch {
return new Set();
}
}
function saveSelection(projectId: string, selected: Set<string>) {
try {
localStorage.setItem(selectionKey(projectId), JSON.stringify([...selected]));
} catch {
// Storage unavailable: the selection just isn't remembered.
}
}
@@ -64,6 +64,7 @@ interface ProjectTabsClientProps {
overlayComp?: string | null; overlayComp?: string | null;
previewComp?: string | null; previewComp?: string | null;
lutComp?: string | null; lutComp?: string | null;
autoShotThumbnail?: boolean | null;
} | null; } | null;
}; };
clients: Client[]; clients: Client[];
@@ -41,7 +41,7 @@ export default async function KanbanPage({
where: { projectId: id }, where: { projectId: id },
orderBy: [{ status: "asc" }, { sortOrder: "asc" }], orderBy: [{ status: "asc" }, { sortOrder: "asc" }],
include: { include: {
shot: { select: { id: true, shotCode: true, thumbnailUrl: true } }, shot: { select: { id: true, shotCode: true, thumbnailUrl: true, generatedThumbnailUrl: true } },
asset: { select: { id: true, assetCode: true, name: true } }, asset: { select: { id: true, assetCode: true, name: true } },
assignedArtist: { assignedArtist: {
select: { id: true, name: true, email: true, image: true }, select: { id: true, name: true, email: true, image: true },
@@ -69,7 +69,7 @@ export default async function KanbanPage({
]); ]);
return ( return (
<div className="p-6 space-y-6 max-w-[1800px] mx-auto"> <div className="p-4 md:p-6 space-y-6 max-w-[1800px] mx-auto">
{/* Breadcrumb */} {/* Breadcrumb */}
<div className="flex items-center gap-2 text-sm text-muted-foreground"> <div className="flex items-center gap-2 text-sm text-muted-foreground">
<Link href="/projects" className="hover:text-foreground transition-colors"> <Link href="/projects" className="hover:text-foreground transition-colors">
+3 -2
View File
@@ -60,7 +60,7 @@ async function getProject(id: string) {
tasks: { tasks: {
orderBy: [{ status: "asc" }, { sortOrder: "asc" }], orderBy: [{ status: "asc" }, { sortOrder: "asc" }],
include: { include: {
shot: { select: { id: true, shotCode: true, thumbnailUrl: true } }, shot: { select: { id: true, shotCode: true, thumbnailUrl: true, generatedThumbnailUrl: true } },
asset: { select: { id: true, assetCode: true, name: true } }, asset: { select: { id: true, assetCode: true, name: true } },
assignedArtist: { select: { id: true, name: true, email: true, image: true } }, assignedArtist: { select: { id: true, name: true, email: true, image: true } },
_count: { select: { versions: true } }, _count: { select: { versions: true } },
@@ -123,7 +123,7 @@ export default async function ProjectPage({ params }: { params: Promise<{ id: st
const doneTasks = project.tasks.filter((t) => t.status === "DONE").length; const doneTasks = project.tasks.filter((t) => t.status === "DONE").length;
return ( return (
<div className="p-8 space-y-6 max-w-[1600px] mx-auto"> <div className="p-4 md:p-8 space-y-6 max-w-[1600px] mx-auto">
{/* Breadcrumb */} {/* Breadcrumb */}
<div className="flex items-center gap-2 text-sm text-zinc-500"> <div className="flex items-center gap-2 text-sm text-zinc-500">
<Link href="/projects" className="hover:text-white transition-colors"> <Link href="/projects" className="hover:text-white transition-colors">
@@ -207,6 +207,7 @@ export default async function ProjectPage({ params }: { params: Promise<{ id: st
overlayComp?: string | null; overlayComp?: string | null;
previewComp?: string | null; previewComp?: string | null;
lutComp?: string | null; lutComp?: string | null;
autoShotThumbnail?: boolean | null;
} | null, } | null,
}} }}
clients={clients} clients={clients}
@@ -76,6 +76,7 @@ const PRIORITY_CONFIG: Record<string, { label: string; dot: string }> = {
}; };
import { useToast } from "@/components/ui/use-toast"; import { useToast } from "@/components/ui/use-toast";
import { shotThumbnail } from "@/lib/shot-thumbnail";
export default function ShotDetailPage() { export default function ShotDetailPage() {
const params = useParams<{ id: string; shotId: string }>(); const params = useParams<{ id: string; shotId: string }>();
@@ -229,7 +230,7 @@ export default function ShotDetailPage() {
const { Icon: StatusIcon } = statusCfg; const { Icon: StatusIcon } = statusCfg;
return ( return (
<div className="p-6 space-y-6 max-w-[1400px] mx-auto"> <div className="p-4 md:p-6 space-y-6 max-w-[1400px] mx-auto">
{/* Breadcrumb */} {/* Breadcrumb */}
<div className="flex items-center gap-2 text-sm text-muted-foreground"> <div className="flex items-center gap-2 text-sm text-muted-foreground">
<Link href="/projects" className="hover:text-foreground transition-colors"> <Link href="/projects" className="hover:text-foreground transition-colors">
@@ -244,28 +245,30 @@ export default function ShotDetailPage() {
</div> </div>
{/* Header */} {/* Header */}
<div className="flex items-start gap-6"> {/* Phones: back button, then a full-width thumbnail, then the details
below it. From md: one row, as on desktop. */}
<div className="flex flex-wrap md:flex-nowrap items-start gap-4 md:gap-6">
{/* Thumbnail – cinema scope 2.39:1 */} {/* Thumbnail – cinema scope 2.39:1 */}
<Button variant="ghost" size="icon" asChild className="-ml-2 h-8 w-8"> <Button variant="ghost" size="icon" asChild className="-ml-2 h-8 w-8">
<Link href={`/projects/${params.id}`}> <Link href={`/projects/${params.id}`}>
<ArrowLeft className="h-4 w-4" /> <ArrowLeft className="h-4 w-4" />
</Link> </Link>
</Button> </Button>
{shot.thumbnailUrl && ( {shotThumbnail(shot) && (
<div className="relative flex-shrink-0 w-72 aspect-[2.39] rounded-lg overflow-hidden border border-border"> <div className="relative flex-shrink-0 w-full md:w-72 aspect-[2.39] rounded-lg overflow-hidden border border-border">
<Image <Image
src={shot.thumbnailUrl} src={shotThumbnail(shot)!}
alt={shot.shotCode} alt={shot.shotCode}
fill fill
className="object-cover" className="object-cover"
/> />
</div> </div>
)} )}
<div className="space-y-2"> <div className="space-y-2 min-w-0 w-full md:w-auto md:min-w-min">
<div className="flex items-center gap-3"> <div className="flex flex-wrap items-center gap-3">
<h1 className="text-2xl font-bold font-mono">{shot.shotCode}</h1> <h1 className="text-2xl font-bold font-mono break-all md:break-normal">{shot.shotCode}</h1>
{/* Shot version badge — click to edit for managers */} {/* Shot version badge — click to edit for managers */}
{canManage ? ( {canManage ? (
@@ -423,7 +426,7 @@ export default function ShotDetailPage() {
)} )}
{canManage && ( {canManage && (
<div className="ml-auto shrink-0 flex items-center gap-2"> <div className="ml-auto shrink-0 flex flex-wrap md:flex-nowrap items-center gap-2 w-full md:w-auto">
{/* Internal approval action */} {/* Internal approval action */}
{canInternallyApprove && shot.shotApprovalStatus === "PENDING" && ( {canInternallyApprove && shot.shotApprovalStatus === "PENDING" && (
<Button <Button
@@ -509,7 +512,8 @@ export default function ShotDetailPage() {
{/* Tabs */} {/* Tabs */}
<div> <div>
<div className="flex border-b border-border mb-5"> {/* Phones: five tabs are wider than the screen, so the bar scrolls sideways. */}
<div className="flex border-b border-border mb-5 overflow-x-auto overflow-y-hidden md:overflow-visible [&>button]:shrink-0 [&>button]:whitespace-nowrap">
<button <button
onClick={() => setActiveTab("tasks")} onClick={() => setActiveTab("tasks")}
className={cn( className={cn(
+9 -17
View File
@@ -1,6 +1,6 @@
"use client"; "use client";
import { useState, useEffect } from "react"; import { useState, useEffect, useRef } from "react";
import { useQuery } from "@tanstack/react-query"; import { useQuery } from "@tanstack/react-query";
import { Button } from "@/components/ui/button"; import { Button } from "@/components/ui/button";
import { Input } from "@/components/ui/input"; import { Input } from "@/components/ui/input";
@@ -8,6 +8,7 @@ import { ProjectCard } from "@/components/projects/ProjectCard";
import { NewProjectDialog } from "@/components/projects/NewProjectDialog"; import { NewProjectDialog } from "@/components/projects/NewProjectDialog";
import { Plus, Search, Loader2 } from "lucide-react"; import { Plus, Search, Loader2 } from "lucide-react";
import { HIDE_ARCHIVED_KEY } from "@/components/settings/HideArchivedToggle"; import { HIDE_ARCHIVED_KEY } from "@/components/settings/HideArchivedToggle";
import { useScrollMemory } from "@/hooks/use-scroll-memory";
export default function ProjectsPage() { export default function ProjectsPage() {
const [search, setSearch] = useState(""); const [search, setSearch] = useState("");
@@ -43,22 +44,11 @@ export default function ProjectsPage() {
const visibleProjects = hideArchived ? projects.filter((p: any) => p.status !== "ARCHIVED") : projects; const visibleProjects = hideArchived ? projects.filter((p: any) => p.status !== "ARCHIVED") : projects;
const SCROLL_KEY = 'projects-scroll'; const pageRef = useRef<HTMLDivElement>(null);
useScrollMemory("projects", pageRef, !isLoading);
useEffect(() => {
if (!isLoading) {
const saved = sessionStorage.getItem(SCROLL_KEY);
if (saved) {
sessionStorage.removeItem(SCROLL_KEY);
requestAnimationFrame(() => window.scrollTo(0, parseInt(saved, 10)));
}
}
}, [isLoading]);
const saveScroll = () => sessionStorage.setItem(SCROLL_KEY, String(window.scrollY));
return ( return (
<div className="p-8 space-y-6 max-w-[1600px] mx-auto"> <div ref={pageRef} className="p-4 md:p-8 space-y-6 max-w-[1600px] mx-auto">
<div className="flex items-center justify-between gap-4 mb-8"> <div className="flex items-center justify-between gap-4 mb-8">
<div> <div>
<h1 className="text-3xl font-bold text-white">Projects</h1> <h1 className="text-3xl font-bold text-white">Projects</h1>
@@ -104,9 +94,11 @@ export default function ProjectsPage() {
</Button> </Button>
</div> </div>
) : ( ) : (
<div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4 gap-4"> // auto-rows-fr keeps every row the same height, so a project with a
// long description does not make its whole row taller than the rest.
<div className="grid auto-rows-fr grid-cols-1 gap-4 sm:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4">
{visibleProjects.map((project: any) => ( {visibleProjects.map((project: any) => (
<div key={project.id} onClick={saveScroll}> <div key={project.id} className="h-full">
<ProjectCard project={project} /> <ProjectCard project={project} />
</div> </div>
))} ))}
@@ -53,7 +53,12 @@ export interface ScheduleTask {
email: string; email: string;
image: string | null; image: string | null;
} | null; } | null;
shot: { id: string; shotCode: string; thumbnailUrl: string | null } | null; shot: {
id: string;
shotCode: string;
thumbnailUrl: string | null;
generatedThumbnailUrl: string | null;
} | null;
asset: { id: string; assetCode: string; name: string } | null; asset: { id: string; assetCode: string; name: string } | null;
project: { id: string; name: string; code: string }; project: { id: string; name: string; code: string };
} }
+2 -2
View File
@@ -31,7 +31,7 @@ export default async function SchedulePage({
...(artist ? { assignedArtistId: artist } : {}), ...(artist ? { assignedArtistId: artist } : {}),
}, },
include: { include: {
shot: { select: { id: true, shotCode: true, thumbnailUrl: true } }, shot: { select: { id: true, shotCode: true, thumbnailUrl: true, generatedThumbnailUrl: true } },
asset: { select: { id: true, assetCode: true, name: true } }, asset: { select: { id: true, assetCode: true, name: true } },
project: { select: { id: true, name: true, code: true } }, project: { select: { id: true, name: true, code: true } },
assignedArtist: { assignedArtist: {
@@ -49,7 +49,7 @@ export default async function SchedulePage({
...(artist ? { assignedArtistId: artist } : {}), ...(artist ? { assignedArtistId: artist } : {}),
}, },
include: { include: {
shot: { select: { id: true, shotCode: true, thumbnailUrl: true } }, shot: { select: { id: true, shotCode: true, thumbnailUrl: true, generatedThumbnailUrl: true } },
asset: { select: { id: true, assetCode: true, name: true } }, asset: { select: { id: true, assetCode: true, name: true } },
project: { select: { id: true, name: true, code: true } }, project: { select: { id: true, name: true, code: true } },
assignedArtist: { assignedArtist: {
+3 -3
View File
@@ -186,7 +186,7 @@ export default function MigrationPage() {
if (fetchError) { if (fetchError) {
return ( return (
<div className="p-6 max-w-2xl"> <div className="p-4 md:p-6 max-w-2xl">
<div className="flex items-center gap-2 text-sm text-red-400 rounded-md border border-red-500/20 bg-red-500/10 px-3 py-2"> <div className="flex items-center gap-2 text-sm text-red-400 rounded-md border border-red-500/20 bg-red-500/10 px-3 py-2">
<AlertCircle className="h-4 w-4 shrink-0" /> <AlertCircle className="h-4 w-4 shrink-0" />
{fetchError} {fetchError}
@@ -200,7 +200,7 @@ export default function MigrationPage() {
if (!hetznerConfigured) { if (!hetznerConfigured) {
return ( return (
<div className="p-6 max-w-2xl"> <div className="p-4 md:p-6 max-w-2xl">
<div className="flex items-center gap-2 text-sm text-amber-400 rounded-md border border-amber-500/20 bg-amber-500/10 px-3 py-2"> <div className="flex items-center gap-2 text-sm text-amber-400 rounded-md border border-amber-500/20 bg-amber-500/10 px-3 py-2">
<AlertCircle className="h-4 w-4 shrink-0" /> <AlertCircle className="h-4 w-4 shrink-0" />
Hetzner object storage is not configured. Set{" "} Hetzner object storage is not configured. Set{" "}
@@ -217,7 +217,7 @@ export default function MigrationPage() {
const allFilteredSelected = filtered.length > 0 && filtered.every((f) => selected.has(f.key)); const allFilteredSelected = filtered.length > 0 && filtered.every((f) => selected.has(f.key));
return ( return (
<div className="p-6 space-y-4 max-w-5xl"> <div className="p-4 md:p-6 space-y-4 max-w-5xl">
{/* Header */} {/* Header */}
<div className="flex items-start justify-between gap-4"> <div className="flex items-start justify-between gap-4">
<div> <div>
+1 -1
View File
@@ -19,7 +19,7 @@ export default async function SettingsPage() {
const hetznerConfig = isAdmin ? await getHetznerConfig() : null; const hetznerConfig = isAdmin ? await getHetznerConfig() : null;
return ( return (
<div className="p-6 space-y-6 max-w-2xl mx-auto"> <div className="p-4 md:p-6 space-y-6 max-w-2xl mx-auto">
<h1 className="text-2xl font-bold">Account Settings</h1> <h1 className="text-2xl font-bold">Account Settings</h1>
<Card> <Card>
@@ -72,7 +72,7 @@ export default function StorageTestPage() {
}; };
return ( return (
<div className="p-6 max-w-3xl space-y-6"> <div className="p-4 md:p-6 max-w-3xl space-y-6">
<div> <div>
<h1 className="text-xl font-semibold">Object Storage Playback Test</h1> <h1 className="text-xl font-semibold">Object Storage Playback Test</h1>
<p className="text-sm text-muted-foreground mt-1"> <p className="text-sm text-muted-foreground mt-1">
File diff suppressed because it is too large Load Diff
+63 -2
View File
@@ -2,6 +2,7 @@ import { db } from "@/lib/db";
import { auth } from "@/auth"; import { auth } from "@/auth";
import { redirect } from "next/navigation"; import { redirect } from "next/navigation";
import { ShotStatusClient } from "./ShotStatusClient"; import { ShotStatusClient } from "./ShotStatusClient";
import { summariseShotDelivery } from "@/lib/render-pipeline/shot-delivery-summary";
async function getProjects() { async function getProjects() {
return db.project.findMany({ return db.project.findMany({
@@ -19,8 +20,17 @@ async function getEpisodeDueDatesForProject(projectId: string) {
}); });
} }
/** Everyone a shot can be handed to — clients and deactivated accounts excluded. */
async function getAssignableArtists() {
return db.user.findMany({
where: { isActive: true, role: { not: "CLIENT" } },
select: { id: true, name: true, email: true, image: true },
orderBy: { name: "asc" },
});
}
async function getShotsForProject(projectId: string) { async function getShotsForProject(projectId: string) {
return db.shot.findMany({ const shots = await db.shot.findMany({
where: { projectId }, where: { projectId },
orderBy: [ orderBy: [
{ episode: { sort: "asc", nulls: "last" } }, { episode: { sort: "asc", nulls: "last" } },
@@ -37,13 +47,62 @@ async function getShotsForProject(projectId: string) {
priority: true, priority: true,
dueDate: true, dueDate: true,
thumbnailUrl: true, thumbnailUrl: true,
generatedThumbnailUrl: true,
notes: true, notes: true,
description: true, description: true,
isKeyShot: true, isKeyShot: true,
isScaled: true,
manualDeliveredAt: true,
manualDeliveryNote: true,
manualDeliverySharedWith: true,
// The shot-level version the panel burns into overlays and queueExport
// renders under — not the count of review Versions uploaded.
shotVersion: true,
artist: { select: { id: true, name: true, image: true, email: true } }, artist: { select: { id: true, name: true, image: true, email: true } },
shotGroup: { select: { id: true, name: true } }, shotGroup: { select: { id: true, name: true } },
// Every export, for the packages each went into; the newest live one
// is what is on its way.
exports: {
orderBy: [{ versionNumber: "desc" }, { createdAt: "desc" }],
select: {
versionString: true,
status: true,
deliveryItems: {
select: {
versionString: true,
package: {
select: {
kind: true,
status: true,
packageNumber: true,
createdAt: true,
builtAt: true,
uploadedAt: true,
deliveredAt: true,
sharedWith: true,
},
},
},
},
},
},
}, },
}); });
return shots.map(({ exports, ...shot }) => ({
...shot,
delivery: summariseShotDelivery({
packages: exports.flatMap((e) =>
e.deliveryItems.map((item) => ({ ...item.package, versionString: item.versionString }))
),
manual: {
deliveredAt: shot.manualDeliveredAt,
sharedWith: shot.manualDeliverySharedWith,
note: shot.manualDeliveryNote,
},
latestExport: exports.find((e) => e.status !== "CANCELLED" && e.status !== "ARCHIVED") ?? null,
}),
}));
} }
export default async function ShotStatusPage({ export default async function ShotStatusPage({
@@ -57,10 +116,11 @@ export default async function ShotStatusPage({
const { projectId } = await searchParams; const { projectId } = await searchParams;
const canManage = ["ADMIN", "PRODUCER", "SUPERVISOR"].includes(session.user.role); const canManage = ["ADMIN", "PRODUCER", "SUPERVISOR"].includes(session.user.role);
const [projects, shots, episodeDueDates] = await Promise.all([ const [projects, shots, episodeDueDates, artists] = await Promise.all([
getProjects(), getProjects(),
projectId ? getShotsForProject(projectId) : Promise.resolve([]), projectId ? getShotsForProject(projectId) : Promise.resolve([]),
projectId ? getEpisodeDueDatesForProject(projectId) : Promise.resolve([]), projectId ? getEpisodeDueDatesForProject(projectId) : Promise.resolve([]),
canManage ? getAssignableArtists() : Promise.resolve([]),
]); ]);
const selectedProject = projects.find((p) => p.id === projectId) ?? null; const selectedProject = projects.find((p) => p.id === projectId) ?? null;
@@ -72,6 +132,7 @@ export default async function ShotStatusPage({
selectedProject={selectedProject} selectedProject={selectedProject}
shots={shots as any} shots={shots as any}
episodeDueDates={episodeDueDates} episodeDueDates={episodeDueDates}
artists={artists}
canManage={canManage} canManage={canManage}
/> />
); );
+1 -1
View File
@@ -110,7 +110,7 @@ export function TasksPageClient({
}; };
return ( return (
<div className="p-6 max-w-5xl mx-auto space-y-6"> <div className="p-4 md:p-6 max-w-5xl mx-auto space-y-6">
{/* Header */} {/* Header */}
<div className="flex items-center justify-between"> <div className="flex items-center justify-between">
<div> <div>
+1 -1
View File
@@ -32,7 +32,7 @@ export default async function UsersPage() {
})); }));
return ( return (
<div className="p-6 max-w-5xl mx-auto space-y-6"> <div className="p-4 md:p-6 max-w-5xl mx-auto space-y-6">
<div className="flex items-center gap-3"> <div className="flex items-center gap-3">
<div className="w-10 h-10 rounded-lg bg-amber-500/10 border border-amber-500/20 flex items-center justify-center shrink-0"> <div className="w-10 h-10 rounded-lg bg-amber-500/10 border border-amber-500/20 flex items-center justify-center shrink-0">
<Users className="h-5 w-5 text-amber-400" /> <Users className="h-5 w-5 text-amber-400" />
+124
View File
@@ -0,0 +1,124 @@
import { NextRequest, NextResponse } from "next/server";
import { auth } from "@/auth";
import { db } from "@/lib/db";
import { PLATE_EXTS, parsePlateFilename } from "@/lib/batch-upload-parser";
export type PlatePreviewItemStatus =
| "match" // shot found → a new footage plate will be added
| "duplicate" // the shot already has a plate with this exact filename
| "no-match" // no shot in this project matches the filename
| "unsupported"; // extension is not an accepted video format
export interface PlatePreviewItem {
fileName: string;
shotCode: string | null;
shotId: string | null;
/** Label the new plate will be created with */
label: string;
status: PlatePreviewItemStatus;
/** Number of plates the matched shot already has */
existingPlateCount: number;
}
/**
* POST /api/batch-upload/plates
* Body: { projectId: string; fileNames: string[] }
*
* Previews which shot each footage plate file will be attached to, derived
* from the filename. e.g. "DH2_VFX_058_120_REF.mov" → shot "DH2_VFX_058_120"
* with the label "REF". Nothing is uploaded.
*/
export async function POST(req: NextRequest) {
const session = await auth();
if (!session?.user) return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
let body: unknown;
try {
body = await req.json();
} catch {
return NextResponse.json({ error: "Invalid JSON" }, { status: 400 });
}
const { projectId, fileNames } = body as { projectId?: unknown; fileNames?: unknown };
if (!projectId || typeof projectId !== "string" || !Array.isArray(fileNames)) {
return NextResponse.json(
{ error: "projectId and fileNames[] are required" },
{ status: 400 }
);
}
const shots = await db.shot.findMany({
where: { projectId },
select: {
id: true,
shotCode: true,
footagePlates: { select: { fileName: true } },
},
});
const shotCodes = shots.map((s) => s.shotCode);
const shotByCode = new Map(shots.map((s) => [s.shotCode, s]));
// Several files in one batch can land on the same shot, so keep a running
// count per shot to number the "Plate N" fallback labels correctly.
const allocated = new Map<string, number>();
const items: PlatePreviewItem[] = fileNames.map((fileName: string) => {
const parsed = parsePlateFilename(fileName, shotCodes);
if (!PLATE_EXTS.has(parsed.ext)) {
return {
fileName,
shotCode: null,
shotId: null,
label: "",
status: "unsupported" as const,
existingPlateCount: 0,
};
}
const shot = parsed.shotCode ? shotByCode.get(parsed.shotCode) ?? null : null;
if (!shot) {
return {
fileName,
shotCode: null,
shotId: null,
label: "",
status: "no-match" as const,
existingPlateCount: 0,
};
}
const existingPlateCount = shot.footagePlates.length;
// Re-running a batch shouldn't silently pile up identical plates.
const isDuplicate = shot.footagePlates.some(
(p) => p.fileName.toLowerCase() === fileName.toLowerCase()
);
if (isDuplicate) {
return {
fileName,
shotCode: shot.shotCode,
shotId: shot.id,
label: parsed.label,
status: "duplicate" as const,
existingPlateCount,
};
}
const takenSoFar = allocated.get(shot.id) ?? 0;
allocated.set(shot.id, takenSoFar + 1);
return {
fileName,
shotCode: shot.shotCode,
shotId: shot.id,
label: parsed.label || `Plate ${existingPlateCount + takenSoFar + 1}`,
status: "match" as const,
existingPlateCount,
};
});
return NextResponse.json({ items });
}
@@ -0,0 +1,96 @@
import { NextRequest, NextResponse } from "next/server";
import { auth } from "@/auth";
import { db } from "@/lib/db";
import { revalidatePath } from "next/cache";
export const maxDuration = 30;
/**
* POST /api/batch-upload/plates/upload
* Body: { projectId, shotId, key, fileName, fileSize?, label? }
*
* Commits a footage plate whose bytes were already uploaded straight to
* Hetzner via POST /api/upload/presign, so large .mov plates never pass
* through this server or the reverse proxy.
*/
export async function POST(req: NextRequest) {
const session = await auth();
if (!session?.user) return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
if (!["ADMIN", "PRODUCER", "SUPERVISOR"].includes(session.user.role)) {
return NextResponse.json({ error: "Forbidden" }, { status: 403 });
}
let body: unknown;
try {
body = await req.json();
} catch {
return NextResponse.json({ error: "Invalid JSON" }, { status: 400 });
}
const { projectId, shotId, key, fileName, fileSize, label } = body as {
projectId?: unknown;
shotId?: unknown;
key?: unknown;
fileName?: unknown;
fileSize?: unknown;
label?: unknown;
};
if (
typeof projectId !== "string" ||
typeof shotId !== "string" ||
typeof key !== "string" ||
typeof fileName !== "string" ||
!projectId ||
!shotId ||
!key ||
!fileName
) {
return NextResponse.json(
{ error: "projectId, shotId, key and fileName are required" },
{ status: 400 }
);
}
// The key must be one this app handed out via /api/upload/presign.
if (!key.startsWith("videos/")) {
return NextResponse.json({ error: "Invalid storage key" }, { status: 400 });
}
const shot = await db.shot.findFirst({
where: { id: shotId, projectId },
select: { id: true },
});
if (!shot) return NextResponse.json({ error: "Shot not found" }, { status: 404 });
const last = await db.footagePlate.findFirst({
where: { shotId },
orderBy: { sortOrder: "desc" },
select: { sortOrder: true },
});
const size = typeof fileSize === "number" && Number.isFinite(fileSize) && fileSize > 0
? BigInt(Math.round(fileSize))
: null;
const plate = await db.footagePlate.create({
data: {
shotId,
fileUrl: `/api/files/${key}`,
fileKey: key,
fileName,
fileSize: size,
label: typeof label === "string" ? label.trim().slice(0, 100) : "",
sortOrder: (last?.sortOrder ?? -1) + 1,
},
});
revalidatePath(`/projects/${projectId}`);
revalidatePath(`/projects/${projectId}/shots/${shotId}`);
return NextResponse.json({
success: true,
plateId: plate.id,
label: plate.label,
});
}
+9 -3
View File
@@ -2,7 +2,7 @@ import { NextRequest, NextResponse } from "next/server";
import { auth } from "@/auth"; import { auth } from "@/auth";
import { db } from "@/lib/db"; import { db } from "@/lib/db";
import { uploadToHetzner, deleteFromHetzner } from "@/lib/storage"; import { uploadToHetzner, deleteFromHetzner } from "@/lib/storage";
import { recalcShotStatus } from "@/lib/shot-status"; import { recalcShotStatus, clearStaleShotApproval } from "@/lib/shot-status";
export const maxDuration = 300; // 5 min — large .mov high-res files export const maxDuration = 300; // 5 min — large .mov high-res files
@@ -194,8 +194,14 @@ export async function POST(
data: { status: "INTERNAL_REVIEW" }, data: { status: "INTERNAL_REVIEW" },
}); });
// Recalculate the parent shot's status // Recalculate the parent shot's status, clearing any stale sign-off first so
await recalcShotStatus(shotId).catch(() => {}); // the new version does not land under a shot still reading COMPLETE.
await db
.$transaction(async (tx) => {
await clearStaleShotApproval(tx, shotId);
await recalcShotStatus(shotId, tx);
})
.catch(() => {});
return NextResponse.json({ return NextResponse.json({
success: true, success: true,
+42 -26
View File
@@ -1,21 +1,8 @@
import { NextRequest, NextResponse } from "next/server"; import { NextRequest, NextResponse } from "next/server";
import { db } from "@/lib/db"; import { db } from "@/lib/db";
import { ApprovalStatus } from "@prisma/client"; import { ApprovalStatus } from "@prisma/client";
import { recalcShotStatus } from "@/lib/shot-status"; import { recalcShotStatus, markShotForRevisions } from "@/lib/shot-status";
import { validateReviewToken } from "@/lib/review-auth"; import { validateReviewToken, getOrCreateReviewUser } from "@/lib/review-auth";
async function getOrCreateClientUser(email: string, label?: string | null) {
const existing = await db.user.findUnique({ where: { email } });
if (existing) return existing;
return db.user.create({
data: {
email,
name: label ?? email.split("@")[0],
role: "CLIENT",
isActive: true,
},
});
}
export async function POST( export async function POST(
req: NextRequest, req: NextRequest,
@@ -48,9 +35,12 @@ export async function POST(
} }
if (action === "APPROVE") { if (action === "APPROVE") {
await db.shot.update({ await db.$transaction(async (tx) => {
await tx.shot.update({
where: { id: shotId }, where: { id: shotId },
data: { shotApprovalStatus: "CLIENT_APPROVED", status: "COMPLETE" }, data: { shotApprovalStatus: "CLIENT_APPROVED" },
});
await recalcShotStatus(shotId, tx);
}); });
} else if (action === "NEEDS_CHANGES") { } else if (action === "NEEDS_CHANGES") {
// Increment shotVersion: v001 → v002, v009 → v010, etc. // Increment shotVersion: v001 → v002, v009 → v010, etc.
@@ -59,17 +49,41 @@ export async function POST(
const nextNum = verMatch ? parseInt(verMatch[1], 10) + 1 : 2; const nextNum = verMatch ? parseInt(verMatch[1], 10) + 1 : 2;
const nextVersion = "v" + String(nextNum).padStart(3, "0"); const nextVersion = "v" + String(nextNum).padStart(3, "0");
const user = await getOrCreateReviewUser(session, token);
await db.$transaction(async (tx) => { await db.$transaction(async (tx) => {
await tx.shot.update({ await tx.shot.update({
where: { id: shotId }, where: { id: shotId },
data: { shotApprovalStatus: "PENDING", sharedWithClient: false, shotVersion: nextVersion }, data: { shotVersion: nextVersion },
}); });
// Mark all non-DONE tasks as CHANGES
await tx.task.updateMany({ // Clears the approval, unshares, marks the tasks needing rework and
where: { shotId, status: { not: "DONE" } }, // recalculates — including the case where every task was already DONE,
data: { status: "CHANGES" }, // which used to match nothing and leave the request with no effect.
await markShotForRevisions(tx, shotId);
// The shot-level verdict has to land on the versions too: the dashboard
// counters, the version badges and the client portal's own filters all
// read Version.approvalStatus, so a shot-level change request was
// invisible everywhere those look.
const shown = await tx.version.findMany({
where: { task: { shotId }, isClientVisible: true, isLatest: true },
select: { id: true },
}); });
await recalcShotStatus(shotId, tx); for (const v of shown) {
await tx.approval.create({
data: {
versionId: v.id,
userId: user.id,
status: "NEEDS_CHANGES",
notes: notes ?? "Changes requested on the shot",
},
});
await tx.version.update({
where: { id: v.id },
data: { approvalStatus: "NEEDS_CHANGES" },
});
}
}); });
} else { } else {
return NextResponse.json({ error: "Invalid action" }, { status: 400 }); return NextResponse.json({ error: "Invalid action" }, { status: 400 });
@@ -99,8 +113,7 @@ export async function POST(
return NextResponse.json({ error: "Version not found" }, { status: 404 }); return NextResponse.json({ error: "Version not found" }, { status: 404 });
} }
const email = session.email ?? `client+${token.slice(0, 8)}@review.external`; const user = await getOrCreateReviewUser(session, token);
const user = await getOrCreateClientUser(email, session.label);
// Record approval // Record approval
await db.approval.create({ await db.approval.create({
@@ -126,9 +139,12 @@ export async function POST(
select: { sharedWithClient: true, shotApprovalStatus: true }, select: { sharedWithClient: true, shotApprovalStatus: true },
}); });
if (shot?.sharedWithClient && shot.shotApprovalStatus !== "CLIENT_APPROVED") { if (shot?.sharedWithClient && shot.shotApprovalStatus !== "CLIENT_APPROVED") {
// status is left to the recalc below — writing COMPLETE here was
// overwritten by it anyway, and disagreed with it whenever another
// task on the shot was still on CHANGES.
await db.shot.update({ await db.shot.update({
where: { id: version.task.shot.id }, where: { id: version.task.shot.id },
data: { shotApprovalStatus: "CLIENT_APPROVED", status: "COMPLETE" }, data: { shotApprovalStatus: "CLIENT_APPROVED" },
}); });
} }
} }
@@ -0,0 +1,127 @@
import { NextRequest, NextResponse } from "next/server";
import { db } from "@/lib/db";
import { validateReviewToken, findReviewUser, ownsComment } from "@/lib/review-auth";
/**
* Edit and delete for notes left through a client review link.
*
* A reviewer may only touch their own notes: the studio's comments and those of
* any other review session are read-only here, whatever the link holder sends.
* Ownership is the review session's guest User (lib/review-auth.ts) — the link
* is the credential, so everyone holding it shares that identity.
*/
/** Matches the internal addComment/editComment limits (actions/comments.ts). */
const MAX_LENGTH = 5000;
/** The annotation companion comments written by the drawing tools. */
const ANNOTATION_PREFIX = "✏️ Annotation at frame";
type Ctx = { params: Promise<{ token: string; commentId: string }> };
/**
* Resolves the request to a comment the caller is allowed to change, or the
* response explaining why not.
*
* "Not yours" is deliberately answered with 404 rather than 403: a link holder
* has no business learning which comment ids exist outside their own notes.
*/
async function authorizeCommentEdit(req: NextRequest, ctx: Ctx) {
const { token, commentId } = await ctx.params;
const result = await validateReviewToken(token, req);
if (result.type === "requiresPassword") {
return { error: NextResponse.json({ requiresPassword: true }, { status: 401 }) };
}
if (result.type === "invalid") {
return {
error: NextResponse.json({ error: "Invalid or expired review link" }, { status: 403 }),
};
}
const session = result.session;
const notFound = NextResponse.json({ error: "Comment not found" }, { status: 404 });
const comment = await db.comment.findUnique({
where: { id: commentId },
select: {
id: true,
authorId: true,
versionId: true,
frameNumber: true,
text: true,
version: {
select: {
shot: { select: { projectId: true } },
task: { select: { projectId: true } },
},
},
},
});
if (!comment) return { error: notFound };
// Same project scoping the rest of the portal applies.
const projectId = comment.version.shot?.projectId ?? comment.version.task?.projectId;
if (projectId !== session.projectId) return { error: notFound };
const user = await findReviewUser(session, token);
if (!ownsComment(comment, user?.id)) return { error: notFound };
return { comment };
}
/** PATCH — change the text of one's own note. */
export async function PATCH(req: NextRequest, ctx: Ctx) {
const authorized = await authorizeCommentEdit(req, ctx);
if (authorized.error) return authorized.error;
const { comment } = authorized;
const body = await req.json().catch(() => null);
const text = typeof body?.text === "string" ? body.text.trim() : "";
if (!text) {
return NextResponse.json({ error: "Note text is required" }, { status: 400 });
}
if (text.length > MAX_LENGTH) {
return NextResponse.json(
{ error: `Note must be ${MAX_LENGTH} characters or fewer` },
{ status: 400 }
);
}
// Only the text is editable. The frame a note is pinned to is what the studio
// works from, so moving it would silently repoint feedback someone may have
// already actioned; a note about a different frame is a new note.
const updated = await db.comment.update({
where: { id: comment.id },
data: { text },
include: {
author: { select: { id: true, name: true, image: true, email: true } },
replies: {
orderBy: { createdAt: "asc" },
include: { author: { select: { id: true, name: true, image: true, email: true } } },
},
},
});
return NextResponse.json({ comment: { ...updated, canEdit: true } });
}
/** DELETE — remove one's own note. */
export async function DELETE(req: NextRequest, ctx: Ctx) {
const authorized = await authorizeCommentEdit(req, ctx);
if (authorized.error) return authorized.error;
const { comment } = authorized;
await db.comment.delete({ where: { id: comment.id } });
// A drawing leaves a companion comment; deleting the note without the strokes
// would leave marks on the frame that nothing explains. Mirrors deleteComment
// in actions/comments.ts.
if (comment.text.startsWith(ANNOTATION_PREFIX)) {
await db.annotation.deleteMany({
where: { versionId: comment.versionId, frameNumber: comment.frameNumber },
});
}
return NextResponse.json({ success: true });
}
+4 -18
View File
@@ -1,21 +1,7 @@
import { NextRequest, NextResponse } from "next/server"; import { NextRequest, NextResponse } from "next/server";
import { db } from "@/lib/db"; import { db } from "@/lib/db";
import { slackNotifyNewFeedback } from "@/lib/slack"; import { slackNotifyNewFeedback } from "@/lib/slack";
import { validateReviewToken } from "@/lib/review-auth"; import { validateReviewToken, getOrCreateReviewUser } from "@/lib/review-auth";
/** Find or create a guest user for the client reviewer based on the session email */
async function getOrCreateClientUser(email: string, label?: string | null) {
const existing = await db.user.findUnique({ where: { email } });
if (existing) return existing;
return db.user.create({
data: {
email,
name: label ?? email.split("@")[0],
role: "CLIENT",
isActive: true,
},
});
}
export async function POST( export async function POST(
req: NextRequest, req: NextRequest,
@@ -52,8 +38,7 @@ export async function POST(
} }
// Resolve commenter identity // Resolve commenter identity
const email = session.email ?? `client+${token.slice(0, 8)}@review.external`; const user = await getOrCreateReviewUser(session, token);
const user = await getOrCreateClientUser(email, session.label);
const comment = await db.comment.create({ const comment = await db.comment.create({
data: { data: {
@@ -85,5 +70,6 @@ export async function POST(
}); });
} }
return NextResponse.json({ comment }, { status: 201 }); // canEdit mirrors the GET shape — a note you just wrote is always your own.
return NextResponse.json({ comment: { ...comment, canEdit: true } }, { status: 201 });
} }
+25 -1
View File
@@ -1,6 +1,8 @@
import { NextRequest, NextResponse } from "next/server"; import { NextRequest, NextResponse } from "next/server";
import { db } from "@/lib/db"; import { db } from "@/lib/db";
import { validateReviewToken } from "@/lib/review-auth"; import { validateReviewToken } from "@/lib/review-auth";
import { shotThumbnail } from "@/lib/shot-thumbnail";
import { clientShotCode, clientTaskTitle } from "@/lib/shot-code";
/** GET /api/client/[token]/project — returns project + shots with tasks that have client-visible versions */ /** GET /api/client/[token]/project — returns project + shots with tasks that have client-visible versions */
export async function GET( export async function GET(
@@ -43,12 +45,15 @@ export async function GET(
select: { select: {
id: true, id: true,
shotCode: true, shotCode: true,
clientCode: true,
episode: true, episode: true,
sequence: true, sequence: true,
scene: true,
description: true, description: true,
status: true, status: true,
shotApprovalStatus: true, shotApprovalStatus: true,
thumbnailUrl: true, thumbnailUrl: true,
generatedThumbnailUrl: true,
tasks: { tasks: {
where: { where: {
versions: { some: { isClientVisible: true } }, versions: { some: { isClientVisible: true } },
@@ -113,7 +118,26 @@ export async function GET(
return NextResponse.json({ return NextResponse.json({
project, project,
shots, // Shots the client sees resolve the same way as internally: the reference
// still first, a render-derived one only where the show supplied none.
// Everything the client reads is in their own naming: the alias replaces
// our shot code, and the same swap runs over task titles, which carry the
// code by convention ("UNG_106_010_020_cmp_TT_v004"). The internal code is
// not sent at all — there is nothing here for it to be useful for, and
// leaking it invites the client to quote it back at us.
// The scene is our numbering too, and an alias does not have to share it
// (SNV's "SNV_101_0463_CP_VFX" is our scene 001), so an aliased shot goes
// out without one rather than with a number the client never used.
shots: shots.map(({ generatedThumbnailUrl, clientCode, scene, ...shot }) => ({
...shot,
shotCode: clientShotCode({ ...shot, clientCode }),
scene: clientShotCode({ ...shot, clientCode }) === shot.shotCode ? scene || null : null,
thumbnailUrl: shotThumbnail({ ...shot, generatedThumbnailUrl }),
tasks: shot.tasks.map((task) => ({
...task,
title: clientTaskTitle(task.title, { ...shot, clientCode }),
})),
})),
assetTasks, assetTasks,
sessionLabel: session.label, sessionLabel: session.label,
}); });
@@ -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,6 +1,7 @@
import { NextRequest, NextResponse } from "next/server"; import { NextRequest, NextResponse } from "next/server";
import { db } from "@/lib/db"; import { db } from "@/lib/db";
import { validateReviewToken } from "@/lib/review-auth"; import { validateReviewToken, findReviewUser, ownsComment } from "@/lib/review-auth";
import { clientHighResFilename, clientShotCode, clientTaskTitle } from "@/lib/shot-code";
/** GET /api/client/[token]/versions/[versionId] — returns version + comments for client portal */ /** GET /api/client/[token]/versions/[versionId] — returns version + comments for client portal */
export async function GET( export async function GET(
@@ -40,7 +41,7 @@ export async function GET(
task: { task: {
include: { include: {
project: { select: { id: true, name: true, code: true } }, project: { select: { id: true, name: true, code: true } },
shot: { select: { id: true, shotCode: true, highResKey: true, highResFilename: true } }, shot: { select: { id: true, shotCode: true, clientCode: true, highResKey: true, highResFilename: true } },
asset: { select: { assetCode: true, name: true } }, asset: { select: { assetCode: true, name: true } },
}, },
}, },
@@ -64,7 +65,7 @@ export async function GET(
return NextResponse.json({ error: "Version not found" }, { status: 404 }); return NextResponse.json({ error: "Version not found" }, { status: 404 });
} }
const comments = await db.comment.findMany({ const commentRows = await db.comment.findMany({
where: { versionId }, where: { versionId },
orderBy: { frameNumber: "asc" }, orderBy: { frameNumber: "asc" },
include: { include: {
@@ -78,31 +79,59 @@ export async function GET(
}, },
}); });
// Which notes this reviewer may edit or delete. Read-only: opening a review
// link should not create the guest User, so a session that has never posted
// simply owns nothing. The edit/delete route re-checks this — the flag drives
// the UI, it does not grant anything.
const reviewUser = await findReviewUser(session, token);
const comments = commentRows.map((c) => ({
...c,
canEdit: ownsComment(c, reviewUser?.id),
}));
// Resolve the shot that has the high-res file (comes from version.shot OR version.task.shot) // Resolve the shot that has the high-res file (comes from version.shot OR version.task.shot)
const highResShot = version.shot ?? (version.task as any)?.shot ?? null; const highResShot = version.shot ?? (version.task as any)?.shot ?? null;
// 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 = { const serializedVersion = {
...version, ...version,
fileSize: version.fileSize?.toString() ?? null, 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 // Top-level high-res fields so the client works for both shot and task versions
hasHighRes: !!(highResShot?.highResKey), hasHighRes: versionHighRes || !!(highResShot?.highResKey),
highResShotId: highResShot?.highResKey ? (highResShot.id ?? null) : null, highResSource: versionHighRes ? "version" : highResShot?.highResKey ? "shot" : null,
highResFilename: highResShot?.highResFilename ?? 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 // Expose only whether a high-res file exists on the shot relation, never the storage key
shot: version.shot shot: version.shot
? { ? {
...version.shot, ...version.shot,
shotCode: clientShotCode(version.shot),
clientCode: undefined,
hasHighRes: !!version.shot.highResKey, hasHighRes: !!version.shot.highResKey,
highResFilename: version.shot.highResFilename ?? null, highResFilename: version.shot.highResFilename ?? null,
highResKey: undefined, highResKey: undefined,
} }
: null, : null,
// Task titles carry the shot code by convention, so the player header gets
// the same swap as the shot list (lib/shot-code.ts).
task: version.task task: version.task
? { ? {
...version.task, ...version.task,
title: namingShot ? clientTaskTitle(version.task.title, namingShot) : version.task.title,
shot: (version.task as any)?.shot shot: (version.task as any)?.shot
? { ? {
...((version.task as any).shot), ...((version.task as any).shot),
shotCode: clientShotCode((version.task as any).shot),
clientCode: undefined,
highResKey: undefined, // strip storage key highResKey: undefined, // strip storage key
} }
: null, : null,
@@ -2,20 +2,30 @@ import { NextRequest, NextResponse } from "next/server";
import { toErrorResponse } from "@/lib/render-pipeline/errors"; import { toErrorResponse } from "@/lib/render-pipeline/errors";
import { requirePipelineAdmin } from "@/lib/render-pipeline/session-auth"; import { requirePipelineAdmin } from "@/lib/render-pipeline/session-auth";
import { markDelivered } from "@/lib/render-pipeline/deliveries"; import { markDelivered } from "@/lib/render-pipeline/deliveries";
import { recordShareSchema } from "@/lib/render-pipeline/delivery-handoff";
// ── POST /api/deliveries/{id}/delivered (E19) ──────────────────────────────── // ── POST /api/deliveries/{id}/delivered (E19) ────────────────────────────────
// //
// The folder has been uploaded to the client. Moves every packaged export to // The upload link has been sent to the client. Takes who it was sent to, and
// DELIVERED — the end of the pipeline. // moves every packaged export to DELIVERED — the end of the pipeline.
export async function POST( export async function POST(
_req: NextRequest, req: NextRequest,
{ params }: { params: Promise<{ packageId: string }> } { params }: { params: Promise<{ packageId: string }> }
) { ) {
try { try {
const user = await requirePipelineAdmin(); const user = await requirePipelineAdmin();
const { packageId } = await params; const { packageId } = await params;
const result = await markDelivered(packageId, user.id);
const parsed = recordShareSchema.safeParse(await req.json().catch(() => null));
if (!parsed.success) {
return NextResponse.json(
{ error: parsed.error.issues[0]?.message ?? "Invalid request", details: parsed.error.issues },
{ status: 422 }
);
}
const result = await markDelivered(packageId, parsed.data, user.id);
return NextResponse.json(result); return NextResponse.json(result);
} catch (err) { } catch (err) {
const { body, status } = toErrorResponse(err); const { body, status } = toErrorResponse(err);
@@ -0,0 +1,34 @@
import { NextRequest, NextResponse } from "next/server";
import { toErrorResponse } from "@/lib/render-pipeline/errors";
import { requirePipelineAdmin } from "@/lib/render-pipeline/session-auth";
import { markUploaded } from "@/lib/render-pipeline/deliveries";
import { recordUploadSchema } from "@/lib/render-pipeline/delivery-handoff";
// ── POST /api/deliveries/{id}/uploaded ───────────────────────────────────────
//
// The folder is on the client's portal. Records where, so the package shows as
// waiting to be shared rather than waiting to be uploaded.
export async function POST(
req: NextRequest,
{ params }: { params: Promise<{ packageId: string }> }
) {
try {
const user = await requirePipelineAdmin();
const { packageId } = await params;
const parsed = recordUploadSchema.safeParse(await req.json().catch(() => null));
if (!parsed.success) {
return NextResponse.json(
{ error: parsed.error.issues[0]?.message ?? "Invalid request", details: parsed.error.issues },
{ status: 422 }
);
}
const result = await markUploaded(packageId, parsed.data, user.id);
return NextResponse.json(result);
} catch (err) {
const { body, status } = toErrorResponse(err);
return NextResponse.json(body, { status });
}
}
+3 -1
View File
@@ -1,5 +1,5 @@
import { NextRequest, NextResponse } from "next/server"; import { NextRequest, NextResponse } from "next/server";
import { DeliveryStatus } from "@prisma/client"; import { DeliveryKind, DeliveryStatus } from "@prisma/client";
import { toErrorResponse } from "@/lib/render-pipeline/errors"; import { toErrorResponse } from "@/lib/render-pipeline/errors";
import { requirePipelineUser, requirePipelineAdmin } from "@/lib/render-pipeline/session-auth"; import { requirePipelineUser, requirePipelineAdmin } from "@/lib/render-pipeline/session-auth";
import { import {
@@ -15,10 +15,12 @@ export async function GET(req: NextRequest) {
await requirePipelineUser(); await requirePipelineUser();
const { searchParams } = new URL(req.url); const { searchParams } = new URL(req.url);
const status = searchParams.get("status"); const status = searchParams.get("status");
const kind = searchParams.get("kind");
const result = await listDeliveryPackages({ const result = await listDeliveryPackages({
projectId: searchParams.get("projectId") ?? undefined, projectId: searchParams.get("projectId") ?? undefined,
episode: searchParams.get("episode") ?? undefined, episode: searchParams.get("episode") ?? undefined,
status: status ? (status as DeliveryStatus) : undefined, status: status ? (status as DeliveryStatus) : undefined,
kind: kind ? (kind as DeliveryKind) : undefined,
}); });
return NextResponse.json(result); return NextResponse.json(result);
} catch (err) { } catch (err) {
@@ -0,0 +1,34 @@
import { NextRequest, NextResponse } from "next/server";
import { toErrorResponse } from "@/lib/render-pipeline/errors";
import { requirePipelineAdmin } from "@/lib/render-pipeline/session-auth";
import { cancelDeliveryRequest } from "@/lib/render-pipeline/delivery-requests";
import { cancelRequestSchema } from "@/lib/render-pipeline/delivery-request-state";
// ── POST /api/delivery-requests/{id}/cancel ──────────────────────────────────
//
// The only way a request leaves the awaiting list without being delivered, and
// it has to say why.
export async function POST(
req: NextRequest,
{ params }: { params: Promise<{ requestId: string }> }
) {
try {
const user = await requirePipelineAdmin();
const { requestId } = await params;
const parsed = cancelRequestSchema.safeParse(await req.json().catch(() => null));
if (!parsed.success) {
return NextResponse.json(
{ error: parsed.error.issues[0]?.message ?? "Invalid request", details: parsed.error.issues },
{ status: 422 }
);
}
const result = await cancelDeliveryRequest(requestId, parsed.data.reason, user.id);
return NextResponse.json(result);
} catch (err) {
const { body, status } = toErrorResponse(err);
return NextResponse.json(body, { status });
}
}
@@ -0,0 +1,22 @@
import { NextRequest, NextResponse } from "next/server";
import { toErrorResponse } from "@/lib/render-pipeline/errors";
import { requirePipelineUser } from "@/lib/render-pipeline/session-auth";
import { getRequestOptions } from "@/lib/render-pipeline/delivery-requests";
// ── GET /api/delivery-requests/options?projectId= ────────────────────────────
//
// The episodes a request can be logged against.
export async function GET(req: NextRequest) {
try {
await requirePipelineUser();
const projectId = new URL(req.url).searchParams.get("projectId");
if (!projectId) {
return NextResponse.json({ error: "projectId is required" }, { status: 400 });
}
return NextResponse.json(await getRequestOptions(projectId));
} catch (err) {
const { body, status } = toErrorResponse(err);
return NextResponse.json(body, { status });
}
}
+44
View File
@@ -0,0 +1,44 @@
import { NextRequest, NextResponse } from "next/server";
import { toErrorResponse } from "@/lib/render-pipeline/errors";
import { requirePipelineAdmin, requirePipelineUser } from "@/lib/render-pipeline/session-auth";
import { createDeliveryRequest, listDeliveryRequests } from "@/lib/render-pipeline/delivery-requests";
import { createRequestSchema } from "@/lib/render-pipeline/delivery-request-state";
// ── GET /api/delivery-requests · POST /api/delivery-requests ─────────────────
//
// What clients have asked for, and how much of each ask has gone out.
export async function GET(req: NextRequest) {
try {
await requirePipelineUser();
const { searchParams } = new URL(req.url);
const requests = await listDeliveryRequests({
projectId: searchParams.get("projectId") ?? undefined,
openOnly: searchParams.get("open") === "1",
});
return NextResponse.json({ requests });
} catch (err) {
const { body, status } = toErrorResponse(err);
return NextResponse.json(body, { status });
}
}
export async function POST(req: NextRequest) {
try {
const user = await requirePipelineAdmin();
const parsed = createRequestSchema.safeParse(await req.json().catch(() => null));
if (!parsed.success) {
return NextResponse.json(
{ error: parsed.error.issues[0]?.message ?? "Invalid request", details: parsed.error.issues },
{ status: 422 }
);
}
const result = await createDeliveryRequest(parsed.data, user.id);
return NextResponse.json(result, { status: 201 });
} catch (err) {
const { body, status } = toErrorResponse(err);
return NextResponse.json(body, { status });
}
}
@@ -1,5 +1,6 @@
import { NextRequest, NextResponse } from "next/server"; import { NextRequest, NextResponse } from "next/server";
import { db } from "@/lib/db"; import { db } from "@/lib/db";
import { shotThumbnail } from "@/lib/shot-thumbnail";
// ── Auth ───────────────────────────────────────────────────────────────────── // ── Auth ─────────────────────────────────────────────────────────────────────
@@ -91,6 +92,7 @@ export async function GET(
seqTimecodeStart: true, seqTimecodeStart: true,
seqTimecodeEnd: true, seqTimecodeEnd: true,
thumbnailUrl: true, thumbnailUrl: true,
generatedThumbnailUrl: true,
artist: { artist: {
select: { id: true, name: true, email: true }, select: { id: true, name: true, email: true },
}, },
@@ -111,6 +113,9 @@ export async function GET(
return NextResponse.json({ return NextResponse.json({
project, project,
pagination: { page, limit, total, pages: Math.ceil(total / limit) }, pagination: { page, limit, total, pages: Math.ceil(total / limit) },
shots, shots: shots.map(({ generatedThumbnailUrl, ...shot }) => ({
...shot,
thumbnailUrl: shotThumbnail({ ...shot, generatedThumbnailUrl }),
})),
}); });
} }
@@ -0,0 +1,62 @@
import { NextRequest, NextResponse } from "next/server";
import { isExtAuthorized } from "@/lib/render-pipeline/ext-auth";
import { toErrorResponse, PipelineError } from "@/lib/render-pipeline/errors";
import { isArtifactKey } from "@/lib/render-pipeline/artifact-kinds";
import { db } from "@/lib/db";
import { abortHetznerMultipartUpload, completeHetznerMultipartUpload } from "@/lib/storage";
// ── POST /api/ext/render/jobs/{jobId}/artifact-complete (E20b) ───────────────
//
// Closes a multipart upload started by artifact-presign: stitches the parts
// (by part number + ETag) into the final object, or with `abort: true` throws
// the stored parts away after the worker gave up.
export async function POST(
req: NextRequest,
{ params }: { params: Promise<{ jobId: string }> }
) {
if (!isExtAuthorized(req)) {
return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
}
const { jobId } = await params;
let body: {
machineId?: string;
key?: string;
uploadId?: string;
parts?: { partNumber?: number; etag?: string }[];
abort?: boolean;
};
try {
body = await req.json();
} catch {
return NextResponse.json({ error: "Invalid JSON" }, { status: 400 });
}
try {
if (!body.machineId) throw new PipelineError(400, "machineId is required");
if (!body.key || !isArtifactKey(body.key)) throw new PipelineError(422, "key is not a worker artifact key");
if (!body.uploadId) throw new PipelineError(400, "uploadId is required");
const job = await db.renderJob.findUnique({ where: { id: jobId }, select: { machineId: true } });
if (!job) throw new PipelineError(404, "Render job not found");
if (job.machineId !== body.machineId) {
throw new PipelineError(409, "Job is not held by this machine (lease reassigned?)");
}
if (body.abort) {
await abortHetznerMultipartUpload(body.key, body.uploadId);
return NextResponse.json({ ok: true, aborted: true });
}
const parts = (body.parts ?? []).filter(
(p): p is { partNumber: number; etag: string } =>
typeof p.partNumber === "number" && typeof p.etag === "string" && p.etag.length > 0
);
if (parts.length === 0) throw new PipelineError(422, "parts are required");
await completeHetznerMultipartUpload(body.key, body.uploadId, parts);
return NextResponse.json({ ok: true, key: body.key, url: `/api/files/${body.key}` });
} catch (err) {
const { body: errBody, status } = toErrorResponse(err);
return NextResponse.json(errBody, { status });
}
}
@@ -3,20 +3,29 @@ import { randomUUID } from "crypto";
import { isExtAuthorized } from "@/lib/render-pipeline/ext-auth"; import { isExtAuthorized } from "@/lib/render-pipeline/ext-auth";
import { toErrorResponse, PipelineError } from "@/lib/render-pipeline/errors"; import { toErrorResponse, PipelineError } from "@/lib/render-pipeline/errors";
import { db } from "@/lib/db"; import { db } from "@/lib/db";
import { generateHetznerPresignedUploadUrl, sanitizeFileName } from "@/lib/storage"; import { ARTIFACT_KIND_FOLDERS } from "@/lib/render-pipeline/artifact-kinds";
import {
createHetznerMultipartUpload,
generateHetznerPresignedUploadUrl,
sanitizeFileName,
} from "@/lib/storage";
// ── POST /api/ext/render/jobs/{jobId}/artifact-presign (E20) ───────────────── // ── POST /api/ext/render/jobs/{jobId}/artifact-presign (E20) ─────────────────
// //
// Presigned upload URL for worker artifacts. Kinds map to the existing object // Presigned upload URL for worker artifacts. Kinds map to the existing object
// storage folder layout: preview → videos/, thumbnail → image/, // 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.
//
// `multipart: true` + `size` (worker ≥ 1.7.2) returns an S3 multipart upload
// instead — an uploadId and one presigned URL per part — which the worker
// fills in parallel and closes with artifact-complete (E20b). A single PUT
// from the studio is capped near 0.1 MB/s; parallel parts scale with the
// number of connections. Older workers never ask and get the single PUT.
const KIND_FOLDERS: Record<string, string> = { const KIND_FOLDERS = ARTIFACT_KIND_FOLDERS;
preview: "videos", const MIN_PART = 8 * 1024 * 1024;
thumbnail: "image", const MAX_PARTS = 10000; // S3 limit
metadata: "renders",
log: "renders",
};
export async function POST( export async function POST(
req: NextRequest, req: NextRequest,
@@ -26,7 +35,14 @@ export async function POST(
return NextResponse.json({ error: "Unauthorized" }, { status: 401 }); return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
} }
const { jobId } = await params; const { jobId } = await params;
let body: { machineId?: string; kind?: string; fileName?: string; contentType?: string }; let body: {
machineId?: string;
kind?: string;
fileName?: string;
contentType?: string;
multipart?: boolean;
size?: number;
};
try { try {
body = await req.json(); body = await req.json();
} catch { } catch {
@@ -48,6 +64,14 @@ export async function POST(
} }
const key = `${folder}/${randomUUID()}-${sanitizeFileName(body.fileName)}`; const key = `${folder}/${randomUUID()}-${sanitizeFileName(body.fileName)}`;
if (body.multipart && typeof body.size === "number" && body.size > MIN_PART) {
const partSize = Math.max(MIN_PART, Math.ceil(body.size / MAX_PARTS));
const partCount = Math.ceil(body.size / partSize);
const { uploadId, partUrls } = await createHetznerMultipartUpload(key, body.contentType, partCount);
return NextResponse.json({ key, url: `/api/files/${key}`, uploadId, partSize, partUrls });
}
const presignedUrl = await generateHetznerPresignedUploadUrl(key, body.contentType); const presignedUrl = await generateHetznerPresignedUploadUrl(key, body.contentType);
return NextResponse.json({ presignedUrl, key, url: `/api/files/${key}` }); return NextResponse.json({ presignedUrl, key, url: `/api/files/${key}` });
} catch (err) { } catch (err) {
@@ -0,0 +1,38 @@
import { NextRequest, NextResponse } from "next/server";
import { isExtAuthorized } from "@/lib/render-pipeline/ext-auth";
import { toErrorResponse } from "@/lib/render-pipeline/errors";
import { attachHighRes, type AttachHighResInput } from "@/lib/render-pipeline/preview";
// ── POST /api/ext/render/jobs/{jobId}/attach-highres (E13b) ──────────────────
//
// The preview's ProRes MOV, uploaded in the background after finalize (worker
// ≥ 1.7.1). Attaches it to the version as its High Res download, or records on
// the export timeline that the upload failed.
export async function POST(
req: NextRequest,
{ params }: { params: Promise<{ jobId: string }> }
) {
if (!isExtAuthorized(req)) {
return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
}
const { jobId } = await params;
let body: AttachHighResInput & { machineId?: string };
try {
body = await req.json();
} catch {
return NextResponse.json({ error: "Invalid JSON" }, { status: 400 });
}
if (!body.machineId) {
return NextResponse.json({ error: "machineId is required" }, { status: 400 });
}
try {
const result = await attachHighRes(jobId, body.machineId, body);
return NextResponse.json(result);
} catch (err) {
const { body: errBody, status } = toErrorResponse(err);
return NextResponse.json(errBody, { status });
}
}
+6 -1
View File
@@ -1,5 +1,6 @@
import { NextRequest, NextResponse } from "next/server"; import { NextRequest, NextResponse } from "next/server";
import { db } from "@/lib/db"; import { db } from "@/lib/db";
import { shotThumbnail } from "@/lib/shot-thumbnail";
// ── Auth ───────────────────────────────────────────────────────────────────── // ── Auth ─────────────────────────────────────────────────────────────────────
@@ -67,6 +68,7 @@ export async function GET(req: NextRequest) {
seqTimecodeEnd: true, seqTimecodeEnd: true,
shotVersion: true, shotVersion: true,
thumbnailUrl: true, thumbnailUrl: true,
generatedThumbnailUrl: true,
createdAt: true, createdAt: true,
updatedAt: true, updatedAt: true,
project: { project: {
@@ -104,5 +106,8 @@ export async function GET(req: NextRequest) {
return NextResponse.json({ error: "Shot not found" }, { status: 404 }); return NextResponse.json({ error: "Shot not found" }, { status: 404 });
} }
return NextResponse.json({ shot }); const { generatedThumbnailUrl, ...rest } = shot;
return NextResponse.json({
shot: { ...rest, thumbnailUrl: shotThumbnail(shot) },
});
} }
+15 -1
View File
@@ -1,6 +1,7 @@
import { NextRequest, NextResponse } from "next/server"; import { NextRequest, NextResponse } from "next/server";
import { auth } from "@/auth"; import { auth } from "@/auth";
import { db } from "@/lib/db"; import { db } from "@/lib/db";
import { shotThumbnail } from "@/lib/shot-thumbnail";
export async function GET(req: NextRequest) { export async function GET(req: NextRequest) {
const session = await auth(); const session = await auth();
@@ -33,6 +34,7 @@ export async function GET(req: NextRequest) {
shotApprovalStatus: true, shotApprovalStatus: true,
sharedWithClient: true, sharedWithClient: true,
thumbnailUrl: true, thumbnailUrl: true,
generatedThumbnailUrl: true,
tasks: { tasks: {
select: { select: {
id: true, id: true,
@@ -48,6 +50,12 @@ export async function GET(req: NextRequest) {
thumbnailUrl: true, thumbnailUrl: true,
posterUrl: true, posterUrl: true,
fps: true, fps: true,
duration: true,
frameCount: true,
hqFileUrl: true,
handleHead: true,
handleTail: true,
pictureStartFrame: true,
approvalStatus: true, approvalStatus: true,
mimeType: true, mimeType: true,
createdAt: true, createdAt: true,
@@ -75,7 +83,7 @@ export async function GET(req: NextRequest) {
status: shot.status, status: shot.status,
shotApprovalStatus: shot.shotApprovalStatus, shotApprovalStatus: shot.shotApprovalStatus,
sharedWithClient: shot.sharedWithClient, sharedWithClient: shot.sharedWithClient,
thumbnailUrl: shot.thumbnailUrl, thumbnailUrl: shotThumbnail(shot),
latestVersion: { latestVersion: {
id: latest.id, id: latest.id,
versionNumber: latest.versionNumber, versionNumber: latest.versionNumber,
@@ -83,6 +91,12 @@ export async function GET(req: NextRequest) {
thumbnailUrl: latest.thumbnailUrl, thumbnailUrl: latest.thumbnailUrl,
posterUrl: latest.posterUrl, posterUrl: latest.posterUrl,
fps: latest.fps, fps: latest.fps,
duration: latest.duration,
frameCount: latest.frameCount,
hqFileUrl: latest.hqFileUrl,
handleHead: latest.handleHead,
handleTail: latest.handleTail,
pictureStartFrame: latest.pictureStartFrame,
approvalStatus: latest.approvalStatus, approvalStatus: latest.approvalStatus,
taskTitle: latest.taskTitle, taskTitle: latest.taskTitle,
}, },
+5
View File
@@ -1,6 +1,7 @@
import { NextResponse } from "next/server"; import { NextResponse } from "next/server";
import { auth } from "@/auth"; import { auth } from "@/auth";
import { db } from "@/lib/db"; import { db } from "@/lib/db";
import { getProjectPosters } from "@/lib/project-poster";
export async function GET(req: Request) { export async function GET(req: Request) {
const session = await auth(); const session = await auth();
@@ -53,9 +54,13 @@ export async function GET(req: Request) {
statsMap.set(row.projectId, existing); statsMap.set(row.projectId, existing);
} }
// One still per project for the card art, chosen from the shots themselves.
const posters = await getProjectPosters(projects.map((p) => p.id));
const projectsWithStats = projects.map((p) => ({ const projectsWithStats = projects.map((p) => ({
...p, ...p,
shotStats: statsMap.get(p.id) ?? { total: 0, approved: 0, inProgress: 0 }, shotStats: statsMap.get(p.id) ?? { total: 0, approved: 0, inProgress: 0 },
poster: posters.get(p.id) ?? null,
})); }));
return NextResponse.json({ projects: projectsWithStats }); return NextResponse.json({ projects: projectsWithStats });
+2 -1
View File
@@ -7,7 +7,7 @@ import { listExports } from "@/lib/render-pipeline/exports";
// ── GET /api/render/queue (E21) ────────────────────────────────────────────── // ── GET /api/render/queue (E21) ──────────────────────────────────────────────
// //
// Exports list for the Render Queue page. Optional filters: projectId, // Exports list for the Render Queue page. Optional filters: projectId,
// episode, status; standard pagination. Defaults to all statuses so the queue // episode, status, q (shot/client code search); standard pagination. Defaults to all statuses so the queue
// page can show history too — the UI filters live states client-side. // page can show history too — the UI filters live states client-side.
export async function GET(req: NextRequest) { export async function GET(req: NextRequest) {
@@ -19,6 +19,7 @@ export async function GET(req: NextRequest) {
projectId: searchParams.get("projectId") ?? undefined, projectId: searchParams.get("projectId") ?? undefined,
episode: searchParams.get("episode") ?? undefined, episode: searchParams.get("episode") ?? undefined,
shotId: searchParams.get("shotId") ?? undefined, shotId: searchParams.get("shotId") ?? undefined,
search: searchParams.get("q")?.slice(0, 100) || undefined,
status: status:
status && (Object.values(ExportStatus) as string[]).includes(status) status && (Object.values(ExportStatus) as string[]).includes(status)
? (status as ExportStatus) ? (status as ExportStatus)
+34
View File
@@ -73,6 +73,40 @@ export async function POST(req: NextRequest) {
return NextResponse.json({ session: reviewSession, portalUrl }, { status: 201 }); return NextResponse.json({ session: reviewSession, portalUrl }, { status: 201 });
} }
/**
* Reactivate a review link: push its expiry `expiresInDays` from now and turn
* it back on. The token is unchanged, so a URL the client already has works
* again rather than a new one having to be sent.
*/
export async function PATCH(req: NextRequest) {
const session = await auth();
if (!session?.user) {
return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
}
if (!["ADMIN", "PRODUCER", "SUPERVISOR"].includes(session.user.role as string)) {
return NextResponse.json({ error: "Forbidden" }, { status: 403 });
}
const id = req.nextUrl.searchParams.get("id");
if (!id) return NextResponse.json({ error: "id required" }, { status: 400 });
const body = await req.json().catch(() => ({}));
const expiresInDays = Number(body.expiresInDays ?? 30);
if (!Number.isInteger(expiresInDays) || expiresInDays < 1 || expiresInDays > 365) {
return NextResponse.json({ error: "expiresInDays must be 1–365" }, { status: 400 });
}
const existing = await db.reviewSession.findUnique({ where: { id }, select: { id: true } });
if (!existing) return NextResponse.json({ error: "Review link not found" }, { status: 404 });
const reviewSession = await db.reviewSession.update({
where: { id },
data: { expiresAt: addDays(new Date(), expiresInDays), isActive: true },
});
return NextResponse.json({ session: reviewSession });
}
export async function DELETE(req: NextRequest) { export async function DELETE(req: NextRequest) {
const session = await auth(); const session = await auth();
if (!session?.user) { if (!session?.user) {
+7 -1
View File
@@ -1,6 +1,7 @@
import { NextRequest, NextResponse } from "next/server"; import { NextRequest, NextResponse } from "next/server";
import { auth } from "@/auth"; import { auth } from "@/auth";
import { db } from "@/lib/db"; import { db } from "@/lib/db";
import { shotThumbnail } from "@/lib/shot-thumbnail";
function requireRole(role: string) { function requireRole(role: string) {
return ["ADMIN", "PRODUCER", "SUPERVISOR"].includes(role); return ["ADMIN", "PRODUCER", "SUPERVISOR"].includes(role);
@@ -27,6 +28,7 @@ export async function GET(
scene: true, scene: true,
episode: true, episode: true,
thumbnailUrl: true, thumbnailUrl: true,
generatedThumbnailUrl: true,
references: { references: {
orderBy: { sortOrder: "asc" }, orderBy: { sortOrder: "asc" },
select: { select: {
@@ -41,5 +43,9 @@ export async function GET(
}); });
if (!shot) return NextResponse.json({ error: "Not found" }, { status: 404 }); if (!shot) return NextResponse.json({ error: "Not found" }, { status: 404 });
return NextResponse.json({ shot });
const { generatedThumbnailUrl, ...rest } = shot;
return NextResponse.json({
shot: { ...rest, thumbnailUrl: shotThumbnail(shot) },
});
} }
+2 -1
View File
@@ -82,7 +82,7 @@ export async function GET(
session.user.role as string session.user.role as string
); );
// Serialize BigInt fields (fileSize) so JSON.stringify doesn't throw // Serialize BigInt fields (fileSize, highResSize) so JSON.stringify doesn't throw
const shotSerialized = { const shotSerialized = {
...shot, ...shot,
footagePlates: shot.footagePlates.map((p) => ({ footagePlates: shot.footagePlates.map((p) => ({
@@ -92,6 +92,7 @@ export async function GET(
versions: shot.versions.map((v) => ({ versions: shot.versions.map((v) => ({
...v, ...v,
fileSize: v.fileSize != null ? v.fileSize.toString() : null, fileSize: v.fileSize != null ? v.fileSize.toString() : null,
highResSize: v.highResSize != null ? v.highResSize.toString() : null,
})), })),
}; };
+7 -1
View File
@@ -1,6 +1,7 @@
import { NextRequest, NextResponse } from "next/server"; import { NextRequest, NextResponse } from "next/server";
import { auth } from "@/auth"; import { auth } from "@/auth";
import { db } from "@/lib/db"; import { db } from "@/lib/db";
import { shotThumbnail } from "@/lib/shot-thumbnail";
// ─── Helpers ────────────────────────────────────────────────────────────────── // ─── Helpers ──────────────────────────────────────────────────────────────────
@@ -409,13 +410,18 @@ export async function GET(req: NextRequest) {
where: { projectId }, where: { projectId },
select: { select: {
id: true, shotCode: true, scene: true, episode: true, shotNumber: true, id: true, shotCode: true, scene: true, episode: true, shotNumber: true,
description: true, notes: true, status: true, thumbnailUrl: true, description: true, notes: true, status: true,
thumbnailUrl: true, generatedThumbnailUrl: true,
frameStart: true, frameEnd: true, fps: true, isKeyShot: true, shotVersion: true, frameStart: true, frameEnd: true, fps: true, isKeyShot: true, shotVersion: true,
shotGroup: { select: { id: true, name: true } }, shotGroup: { select: { id: true, name: true } },
}, },
orderBy: [{ episode: "asc" }, { scene: "asc" }, { shotNumber: "asc" }], orderBy: [{ episode: "asc" }, { scene: "asc" }, { shotNumber: "asc" }],
}); });
// Collapse the two columns before anything reads them, so the "only shots
// with thumbnails" filter and the page renderer agree on what counts as one.
shots = shots.map((s) => ({ ...s, thumbnailUrl: shotThumbnail(s) }));
if (onlyThumbs) shots = shots.filter((s) => !!s.thumbnailUrl); if (onlyThumbs) shots = shots.filter((s) => !!s.thumbnailUrl);
if (epFilter.length) shots = shots.filter((s) => epFilter.includes(s.episode ?? "")); if (epFilter.length) shots = shots.filter((s) => epFilter.includes(s.episode ?? ""));
if (grpFilter.length) shots = shots.filter((s) => grpFilter.includes(s.shotGroup?.id ?? "")); if (grpFilter.length) shots = shots.filter((s) => grpFilter.includes(s.shotGroup?.id ?? ""));
+10 -1
View File
@@ -1,6 +1,7 @@
import { NextRequest, NextResponse } from "next/server"; import { NextRequest, NextResponse } from "next/server";
import { auth } from "@/auth"; import { auth } from "@/auth";
import { db } from "@/lib/db"; import { db } from "@/lib/db";
import { shotThumbnail } from "@/lib/shot-thumbnail";
// GET /api/storyboard/shots?projectId=xxx // GET /api/storyboard/shots?projectId=xxx
export async function GET(req: NextRequest) { export async function GET(req: NextRequest) {
@@ -26,6 +27,7 @@ export async function GET(req: NextRequest) {
notes: true, notes: true,
status: true, status: true,
thumbnailUrl: true, thumbnailUrl: true,
generatedThumbnailUrl: true,
frameStart: true, frameStart: true,
frameEnd: true, frameEnd: true,
fps: true, fps: true,
@@ -40,5 +42,12 @@ export async function GET(req: NextRequest) {
], ],
}); });
return NextResponse.json({ shots }); // The reference still wins; a render-derived one fills the gap where a show
// shipped no stills at all (lib/shot-thumbnail.ts).
return NextResponse.json({
shots: shots.map(({ generatedThumbnailUrl, ...shot }) => ({
...shot,
thumbnailUrl: shotThumbnail({ ...shot, generatedThumbnailUrl }),
})),
});
} }
@@ -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 });
}
+238 -153
View File
@@ -1,6 +1,7 @@
'use client'; 'use client';
import { useState, useEffect } from 'react'; import { useState, useRef, useEffect } from 'react';
import { useScrollMemory } from '@/hooks/use-scroll-memory';
import Link from 'next/link'; import Link from 'next/link';
import Image from 'next/image'; import Image from 'next/image';
import { import {
@@ -18,6 +19,7 @@ import {
Check, Check,
Search, Search,
X, X,
Layers,
} from 'lucide-react'; } from 'lucide-react';
import { cn } from '@/lib/utils'; import { cn } from '@/lib/utils';
import { Montserrat } from 'next/font/google'; import { Montserrat } from 'next/font/google';
@@ -51,6 +53,7 @@ interface ClientShot {
shotCode: string; shotCode: string;
episode: string | null; episode: string | null;
sequence: string | null; sequence: string | null;
scene: string | null;
description: string | null; description: string | null;
status: string; status: string;
thumbnailUrl: string | null; thumbnailUrl: string | null;
@@ -127,7 +130,6 @@ const TASK_TYPE_LABELS: Record<string, string> = {
GENERAL: 'Task', GENERAL: 'Task',
}; };
const SCROLL_KEY = 'client-portal-scroll';
const QUEUE_KEY = 'client-portal-queue'; const QUEUE_KEY = 'client-portal-queue';
const STATE_KEY = 'client-portal-state'; const STATE_KEY = 'client-portal-state';
const PREFS_KEY_PREFIX = 'client-portal-prefs-'; const PREFS_KEY_PREFIX = 'client-portal-prefs-';
@@ -136,6 +138,26 @@ function getLatestVersion(task: ClientTask): ClientVersion | undefined {
return task.versions[0]; return task.versions[0];
} }
const NO_SCENE = '__none__';
/** Shots split into scenes in scene order, with unscened shots last. */
function groupShotsByScene<T extends ClientShot>(shots: T[]): [string, T[]][] {
const map = new Map<string, T[]>();
for (const shot of shots) {
const key = shot.scene || NO_SCENE;
if (!map.has(key)) map.set(key, []);
map.get(key)!.push(shot);
}
return Array.from(map.entries()).sort(([a], [b]) => {
if (a === NO_SCENE) return 1;
if (b === NO_SCENE) return -1;
return a.localeCompare(b, undefined, { numeric: true });
});
}
/** Collapse key for a scene, kept in the same set as the episodes. */
const sceneKey = (episode: string, scene: string) => `${episode}::${scene}`;
export default function ClientPortalPage({ export default function ClientPortalPage({
params, params,
}: { }: {
@@ -152,8 +174,14 @@ export default function ClientPortalPage({
const [collapsedEpisodes, setCollapsedEpisodes] = useState<Set<string>>(new Set()); const [collapsedEpisodes, setCollapsedEpisodes] = useState<Set<string>>(new Set());
const [statusFilter, setStatusFilter] = useState<string | null>(null); const [statusFilter, setStatusFilter] = useState<string | null>(null);
const [sortMode, setSortMode] = useState<'episode' | 'recent'>('episode'); const [sortMode, setSortMode] = useState<'episode' | 'recent'>('episode');
const [groupByScene, setGroupByScene] = useState(false);
const [searchQuery, setSearchQuery] = useState<string>(''); const [searchQuery, setSearchQuery] = useState<string>('');
const [episodeFilter, setEpisodeFilter] = useState<string | null>(null); const [episodeFilter, setEpisodeFilter] = useState<string | null>(null);
// Filters and collapsed episodes set the page height, so the scroll
// position is restored only once they are back.
const [viewRestored, setViewRestored] = useState(false);
const pageRef = useRef<HTMLDivElement>(null);
useScrollMemory(token ? `clientPortal:${token}` : null, pageRef, viewRestored);
const toggleEpisode = (ep: string) => { const toggleEpisode = (ep: string) => {
setCollapsedEpisodes((prev) => { setCollapsedEpisodes((prev) => {
@@ -189,9 +217,10 @@ export default function ClientPortalPage({
if (savedState) { if (savedState) {
sessionStorage.removeItem(STATE_KEY); sessionStorage.removeItem(STATE_KEY);
try { try {
const { statusFilter: sf, sortMode: sm, searchQuery: sq, episodeFilter: ef, collapsedEpisodes: ce } = JSON.parse(savedState); const { statusFilter: sf, sortMode: sm, groupByScene: gs, searchQuery: sq, episodeFilter: ef, collapsedEpisodes: ce } = JSON.parse(savedState);
if (sf !== undefined) setStatusFilter(sf); if (sf !== undefined) setStatusFilter(sf);
if (sm !== undefined) setSortMode(sm); if (sm !== undefined) setSortMode(sm);
if (gs !== undefined) setGroupByScene(gs);
if (sq !== undefined) setSearchQuery(sq ?? ''); if (sq !== undefined) setSearchQuery(sq ?? '');
if (ef !== undefined) setEpisodeFilter(ef); if (ef !== undefined) setEpisodeFilter(ef);
if (ce !== undefined) setCollapsedEpisodes(new Set(ce)); if (ce !== undefined) setCollapsedEpisodes(new Set(ce));
@@ -200,22 +229,17 @@ export default function ClientPortalPage({
try { try {
const prefs = localStorage.getItem(PREFS_KEY_PREFIX + token); const prefs = localStorage.getItem(PREFS_KEY_PREFIX + token);
if (prefs) { if (prefs) {
const { statusFilter: sf, sortMode: sm, searchQuery: sq, episodeFilter: ef, collapsedEpisodes: ce } = JSON.parse(prefs); const { statusFilter: sf, sortMode: sm, groupByScene: gs, searchQuery: sq, episodeFilter: ef, collapsedEpisodes: ce } = JSON.parse(prefs);
if (sf !== undefined) setStatusFilter(sf); if (sf !== undefined) setStatusFilter(sf);
if (sm !== undefined) setSortMode(sm); if (sm !== undefined) setSortMode(sm);
if (gs !== undefined) setGroupByScene(gs);
if (sq !== undefined) setSearchQuery(sq ?? ''); if (sq !== undefined) setSearchQuery(sq ?? '');
if (ef !== undefined) setEpisodeFilter(ef); if (ef !== undefined) setEpisodeFilter(ef);
if (ce !== undefined) setCollapsedEpisodes(new Set(ce)); if (ce !== undefined) setCollapsedEpisodes(new Set(ce));
} }
} catch { /* ignore */ } } catch { /* ignore */ }
} }
const saved = sessionStorage.getItem(SCROLL_KEY); setViewRestored(true);
if (saved) {
sessionStorage.removeItem(SCROLL_KEY);
requestAnimationFrame(() => {
window.scrollTo(0, parseInt(saved, 10));
});
}
} }
}, [loading, token]); }, [loading, token]);
@@ -227,13 +251,14 @@ export default function ClientPortalPage({
JSON.stringify({ JSON.stringify({
statusFilter, statusFilter,
sortMode, sortMode,
groupByScene,
searchQuery, searchQuery,
episodeFilter, episodeFilter,
collapsedEpisodes: Array.from(collapsedEpisodes), collapsedEpisodes: Array.from(collapsedEpisodes),
}), }),
); );
} catch { /* ignore */ } } catch { /* ignore */ }
}, [token, statusFilter, sortMode, searchQuery, episodeFilter, collapsedEpisodes, loading]); }, [token, statusFilter, sortMode, groupByScene, searchQuery, episodeFilter, collapsedEpisodes, loading]);
const loadProject = (t: string) => { const loadProject = (t: string) => {
setLoading(true); setLoading(true);
@@ -310,6 +335,8 @@ export default function ClientPortalPage({
// Group shots by episode; null episode → "Shots" // Group shots by episode; null episode → "Shots"
const isEpisodic = shots.some((s) => s.episode != null); const isEpisodic = shots.some((s) => s.episode != null);
const hasScenes = shots.some((s) => s.scene);
const showScenes = groupByScene && hasScenes;
const shotsByEpisode = shots.reduce<Record<string, ClientShot[]>>( const shotsByEpisode = shots.reduce<Record<string, ClientShot[]>>(
(acc, shot) => { (acc, shot) => {
const key = shot.episode ?? 'Shots'; const key = shot.episode ?? 'Shots';
@@ -410,10 +437,11 @@ export default function ClientPortalPage({
Object.entries(shotsByEpisode) Object.entries(shotsByEpisode)
.filter(([episode]) => episodeFilter === null || episodeFilter === episode) .filter(([episode]) => episodeFilter === null || episodeFilter === episode)
.forEach(([, epShots]) => { .forEach(([, epShots]) => {
epShots const visible = epShots
.map((shot) => ({ ...shot, tasks: shot.tasks.filter(taskMatchesFilter) })) .map((shot) => ({ ...shot, tasks: shot.tasks.filter(taskMatchesFilter) }))
.filter((shot) => shot.tasks.length > 0) .filter((shot) => shot.tasks.length > 0)
.filter(shotMatchesSearch) .filter(shotMatchesSearch);
(showScenes ? groupShotsByScene(visible).flatMap(([, sc]) => sc) : visible)
.forEach((shot) => { .forEach((shot) => {
shot.tasks.forEach((task) => { shot.tasks.forEach((task) => {
const ver = getLatestVersion(task); const ver = getLatestVersion(task);
@@ -429,13 +457,13 @@ export default function ClientPortalPage({
}; };
const handleReviewClick = () => { const handleReviewClick = () => {
sessionStorage.setItem(SCROLL_KEY, String(window.scrollY));
sessionStorage.setItem(QUEUE_KEY, JSON.stringify(getReviewQueue())); sessionStorage.setItem(QUEUE_KEY, JSON.stringify(getReviewQueue()));
sessionStorage.setItem( sessionStorage.setItem(
STATE_KEY, STATE_KEY,
JSON.stringify({ JSON.stringify({
statusFilter, statusFilter,
sortMode, sortMode,
groupByScene,
searchQuery, searchQuery,
episodeFilter, episodeFilter,
collapsedEpisodes: Array.from(collapsedEpisodes), collapsedEpisodes: Array.from(collapsedEpisodes),
@@ -443,8 +471,149 @@ export default function ClientPortalPage({
); );
}; };
// Approved / needs changes / awaiting counts for an episode or scene header.
const statusPills = (tasks: ClientTask[]) => {
const nApproved = tasks.filter(
(t) => getLatestVersion(t)?.approvalStatus === 'APPROVED',
).length;
const nChanges = tasks.filter((t) =>
['REJECTED', 'NEEDS_CHANGES'].includes(
getLatestVersion(t)?.approvalStatus ?? '',
),
).length;
const nPending = tasks.length - nApproved - nChanges;
return ( return (
<div className="min-h-screen bg-zinc-950 text-white"> <div className="flex items-center gap-2 shrink-0">
{nApproved > 0 && (
<span className="inline-flex items-center gap-1 px-2 py-0.5 rounded-full bg-emerald-900/40 border border-emerald-800/40 text-emerald-400 text-xs">
<CheckCircle2 className="h-3 w-3" />
{nApproved}
</span>
)}
{nChanges > 0 && (
<span className="inline-flex items-center gap-1 px-2 py-0.5 rounded-full bg-red-900/30 border border-red-800/30 text-red-400 text-xs">
<AlertCircle className="h-3 w-3" />
{nChanges}
</span>
)}
{nPending > 0 && (
<span className="inline-flex items-center gap-1 px-2 py-0.5 rounded-full bg-amber-900/20 border border-amber-800/20 text-amber-400 text-xs">
<Clock className="h-3 w-3" />
{nPending}
</span>
)}
</div>
);
};
const renderShot = (shot: ClientShot) => (
<div key={shot.id} className="px-5 py-4 space-y-2">
<div className="flex items-center gap-3">
{shot.thumbnailUrl && (
<div className="relative flex-shrink-0 w-32 aspect-[2.39] rounded overflow-hidden border border-zinc-800">
<Image
src={shot.thumbnailUrl}
alt={shot.shotCode}
fill
className="object-cover"
/>
</div>
)}
<div className="flex items-center gap-1.5 group/shotcode">
<p className="font-mono text-sm font-semibold text-zinc-300">
{shot.shotCode}
{shot.description && (
<span className="font-sans font-normal text-zinc-500 ml-2">
{shot.description}
</span>
)}
</p>
<button
onClick={() => copyToClipboard(shot.shotCode, `shot-${shot.id}`)}
className="shrink-0 p-0.5 rounded opacity-0 group-hover/shotcode:opacity-100 text-zinc-600 hover:text-zinc-300 transition-all"
title="Copy shot code"
>
{copiedId === `shot-${shot.id}` ? (
<Check className="h-3 w-3 text-emerald-400" />
) : (
<Copy className="h-3 w-3" />
)}
</button>
</div>
</div>
<div className="space-y-1.5 pl-3 border-l border-zinc-800">
{shot.tasks.map((task) => {
const ver = getLatestVersion(task);
const approvalKey =
ver?.approvalStatus ?? 'PENDING_REVIEW';
const approval =
APPROVAL_STYLES[approvalKey] ??
APPROVAL_STYLES.PENDING_REVIEW;
const ApprovalIcon = approval.Icon;
return (
<Link
key={task.id}
href={ver ? `/client/${token}/review/${ver.id}` : '#'}
onClick={handleReviewClick}
className={cn(
'flex flex-wrap sm:flex-nowrap items-center gap-x-4 gap-y-2 p-3 sm:p-4 rounded-xl border transition-all group',
'bg-zinc-900 border-zinc-800 hover:border-zinc-600 hover:bg-zinc-800/70',
!ver && 'pointer-events-none opacity-40',
)}
>
<div className="min-w-0 w-full sm:w-auto sm:flex-1">
<div className="flex items-center gap-1.5">
<p className="text-sm font-medium text-white min-w-0 break-words">
{task.title}
</p>
<button
onClick={(e) => { e.preventDefault(); e.stopPropagation(); copyToClipboard(task.title, `task-${task.id}`); }}
className="hidden sm:block shrink-0 p-0.5 rounded opacity-0 group-hover:opacity-100 text-zinc-600 hover:text-zinc-300 transition-all"
title="Copy task name"
>
{copiedId === `task-${task.id}` ? (
<Check className="h-3 w-3 text-emerald-400" />
) : (
<Copy className="h-3 w-3" />
)}
</button>
</div>
<p className="text-xs text-zinc-500">
{TASK_TYPE_LABELS[task.type] ?? task.type}
</p>
</div>
{ver ? (
<div className="flex items-center gap-3 shrink-0">
{ver.createdAt && (
<span className="text-xs text-zinc-600 hidden sm:block">
{formatDate(ver.createdAt)}
</span>
)}
<span
className={cn(
'inline-flex items-center gap-1.5 px-2.5 py-1 rounded-full border text-xs font-medium',
approval.className,
)}
>
<ApprovalIcon className="h-3 w-3" />
{approval.label}
</span>
</div>
) : (
<span className="text-xs text-zinc-600 shrink-0">
No versions yet
</span>
)}
<ChevronRight className="h-4 w-4 text-zinc-600 group-hover:text-zinc-400 shrink-0 transition-colors ml-auto sm:ml-0" />
</Link>
);
})}
</div>
</div>
);
return (
<div ref={pageRef} className="min-h-screen bg-zinc-950 text-white">
<header className="border-b border-zinc-800 bg-zinc-900"> <header className="border-b border-zinc-800 bg-zinc-900">
<div className="max-w-5xl mx-auto px-6 py-4 flex items-center justify-between"> <div className="max-w-5xl mx-auto px-6 py-4 flex items-center justify-between">
{/* Logo */} {/* Logo */}
@@ -454,7 +623,7 @@ export default function ClientPortalPage({
</div> </div>
<div className={montserrat.className}> <div className={montserrat.className}>
<span className="block text-2xl font-light text-white leading-none"> <span className="block text-2xl font-light text-white leading-none whitespace-nowrap">
TWO TALES TWO TALES
</span> </span>
@@ -464,7 +633,7 @@ export default function ClientPortalPage({
</div> </div>
</div> </div>
{sessionLabel && ( {sessionLabel && (
<span className="text-sm text-zinc-400">{sessionLabel}</span> <span className="ml-4 min-w-0 truncate text-right text-sm text-zinc-400" title={sessionLabel}>{sessionLabel}</span>
)} )}
</div> </div>
</header> </header>
@@ -620,6 +789,20 @@ export default function ClientPortalPage({
</div> </div>
<div className="flex items-center gap-2"> <div className="flex items-center gap-2">
{hasScenes && sortMode === 'episode' && (
<button
onClick={() => setGroupByScene((prev) => !prev)}
className={cn(
'inline-flex items-center gap-1.5 px-3 py-1.5 rounded-lg text-xs font-medium border transition-all',
groupByScene
? 'bg-amber-500/10 border-amber-500/30 text-amber-400'
: 'bg-zinc-800 border-zinc-700 text-zinc-400 hover:text-zinc-300',
)}
>
<Layers className="h-3 w-3" />
{groupByScene ? 'Grouped by Scene' : 'Group by Scene'}
</button>
)}
<button <button
onClick={() => onClick={() =>
setSortMode((prev) => (prev === 'episode' ? 'recent' : 'episode')) setSortMode((prev) => (prev === 'episode' ? 'recent' : 'episode'))
@@ -687,7 +870,7 @@ export default function ClientPortalPage({
/> />
</div> </div>
)} )}
<div className="flex items-center gap-1.5 group/itemlabel"> <div className="flex min-w-0 items-center gap-1.5 group/itemlabel">
<p className="font-mono text-xs text-zinc-500"> <p className="font-mono text-xs text-zinc-500">
{item.label} {item.label}
{item.description && ( {item.description && (
@@ -698,7 +881,7 @@ export default function ClientPortalPage({
</p> </p>
<button <button
onClick={() => copyToClipboard(item.label, `label-${task.id}`)} onClick={() => copyToClipboard(item.label, `label-${task.id}`)}
className="shrink-0 p-0.5 rounded opacity-0 group-hover/itemlabel:opacity-100 text-zinc-600 hover:text-zinc-300 transition-all" className="hidden sm:block shrink-0 p-0.5 rounded opacity-0 group-hover/itemlabel:opacity-100 text-zinc-600 hover:text-zinc-300 transition-all"
title="Copy name" title="Copy name"
> >
{copiedId === `label-${task.id}` ? ( {copiedId === `label-${task.id}` ? (
@@ -709,7 +892,7 @@ export default function ClientPortalPage({
</button> </button>
</div> </div>
{ver?.createdAt && ( {ver?.createdAt && (
<p className="ml-auto text-xs text-zinc-600"> <p className="ml-auto shrink-0 whitespace-nowrap text-xs text-zinc-600">
{formatDate(ver.createdAt)} {formatDate(ver.createdAt)}
</p> </p>
)} )}
@@ -718,19 +901,19 @@ export default function ClientPortalPage({
href={ver ? `/client/${token}/review/${ver.id}` : '#'} href={ver ? `/client/${token}/review/${ver.id}` : '#'}
onClick={handleReviewClick} onClick={handleReviewClick}
className={cn( className={cn(
'flex items-center gap-4 p-4 rounded-xl border transition-all group', 'flex flex-wrap sm:flex-nowrap items-center gap-x-4 gap-y-2 p-3 sm:p-4 rounded-xl border transition-all group',
'bg-zinc-900 border-zinc-800 hover:border-zinc-600 hover:bg-zinc-800/70', 'bg-zinc-900 border-zinc-800 hover:border-zinc-600 hover:bg-zinc-800/70',
!ver && 'pointer-events-none opacity-40', !ver && 'pointer-events-none opacity-40',
)} )}
> >
<div className="flex-1 min-w-0"> <div className="min-w-0 w-full sm:w-auto sm:flex-1">
<div className="flex items-center gap-1.5"> <div className="flex items-center gap-1.5">
<p className="text-sm font-medium text-white"> <p className="text-sm font-medium text-white min-w-0 break-words">
{task.title} {task.title}
</p> </p>
<button <button
onClick={(e) => { e.preventDefault(); e.stopPropagation(); copyToClipboard(task.title, `task-${task.id}`); }} onClick={(e) => { e.preventDefault(); e.stopPropagation(); copyToClipboard(task.title, `task-${task.id}`); }}
className="shrink-0 p-0.5 rounded opacity-0 group-hover:opacity-100 text-zinc-600 hover:text-zinc-300 transition-all" className="hidden sm:block shrink-0 p-0.5 rounded opacity-0 group-hover:opacity-100 text-zinc-600 hover:text-zinc-300 transition-all"
title="Copy task name" title="Copy task name"
> >
{copiedId === `task-${task.id}` ? ( {copiedId === `task-${task.id}` ? (
@@ -759,7 +942,7 @@ export default function ClientPortalPage({
No versions yet No versions yet
</span> </span>
)} )}
<ChevronRight className="h-4 w-4 text-zinc-600 group-hover:text-zinc-400 shrink-0 transition-colors" /> <ChevronRight className="h-4 w-4 text-zinc-600 group-hover:text-zinc-400 shrink-0 transition-colors ml-auto sm:ml-0" />
</Link> </Link>
</div> </div>
); );
@@ -780,15 +963,6 @@ export default function ClientPortalPage({
const isCollapsed = collapsedEpisodes.has(episode); const isCollapsed = collapsedEpisodes.has(episode);
const epTasks = filteredEpShots.flatMap((s) => s.tasks); const epTasks = filteredEpShots.flatMap((s) => s.tasks);
const epApproved = epTasks.filter(
(t) => getLatestVersion(t)?.approvalStatus === 'APPROVED',
).length;
const epChanges = epTasks.filter((t) =>
['REJECTED', 'NEEDS_CHANGES'].includes(
getLatestVersion(t)?.approvalStatus ?? '',
),
).length;
const epPending = epTasks.length - epApproved - epChanges;
return ( return (
<div key={episode} className="rounded-xl border border-zinc-800 overflow-hidden"> <div key={episode} className="rounded-xl border border-zinc-800 overflow-hidden">
@@ -812,137 +986,48 @@ export default function ClientPortalPage({
{filteredEpShots.length === 1 ? 'shot' : 'shots'} {filteredEpShots.length === 1 ? 'shot' : 'shots'}
</span> </span>
</div> </div>
{/* Per-episode progress pills */} {statusPills(epTasks)}
<div className="flex items-center gap-2 shrink-0">
{epApproved > 0 && (
<span className="inline-flex items-center gap-1 px-2 py-0.5 rounded-full bg-emerald-900/40 border border-emerald-800/40 text-emerald-400 text-xs">
<CheckCircle2 className="h-3 w-3" />
{epApproved}
</span>
)}
{epChanges > 0 && (
<span className="inline-flex items-center gap-1 px-2 py-0.5 rounded-full bg-red-900/30 border border-red-800/30 text-red-400 text-xs">
<AlertCircle className="h-3 w-3" />
{epChanges}
</span>
)}
{epPending > 0 && (
<span className="inline-flex items-center gap-1 px-2 py-0.5 rounded-full bg-amber-900/20 border border-amber-800/20 text-amber-400 text-xs">
<Clock className="h-3 w-3" />
{epPending}
</span>
)}
</div>
</button> </button>
{/* Collapsible shot list */} {/* Collapsible shot list */}
{!isCollapsed && ( {!isCollapsed && (
<div className="divide-y divide-zinc-800/60 bg-zinc-950/40"> <div className="divide-y divide-zinc-800/60 bg-zinc-950/40">
{filteredEpShots.map((shot) => ( {showScenes
<div key={shot.id} className="px-5 py-4 space-y-2"> ? groupShotsByScene(filteredEpShots).map(([scene, sceneShots]) => {
<div className="flex items-center gap-3"> const key = sceneKey(episode, scene);
{shot.thumbnailUrl && ( const sceneCollapsed = collapsedEpisodes.has(key);
<div className="relative flex-shrink-0 w-32 aspect-[2.39] rounded overflow-hidden border border-zinc-800">
<Image
src={shot.thumbnailUrl}
alt={shot.shotCode}
fill
className="object-cover"
/>
</div>
)}
<div className="flex items-center gap-1.5 group/shotcode">
<p className="font-mono text-sm font-semibold text-zinc-300">
{shot.shotCode}
{shot.description && (
<span className="font-sans font-normal text-zinc-500 ml-2">
{shot.description}
</span>
)}
</p>
<button
onClick={() => copyToClipboard(shot.shotCode, `shot-${shot.id}`)}
className="shrink-0 p-0.5 rounded opacity-0 group-hover/shotcode:opacity-100 text-zinc-600 hover:text-zinc-300 transition-all"
title="Copy shot code"
>
{copiedId === `shot-${shot.id}` ? (
<Check className="h-3 w-3 text-emerald-400" />
) : (
<Copy className="h-3 w-3" />
)}
</button>
</div>
</div>
<div className="space-y-1.5 pl-3 border-l border-zinc-800">
{shot.tasks.map((task) => {
const ver = getLatestVersion(task);
const approvalKey =
ver?.approvalStatus ?? 'PENDING_REVIEW';
const approval =
APPROVAL_STYLES[approvalKey] ??
APPROVAL_STYLES.PENDING_REVIEW;
const ApprovalIcon = approval.Icon;
return ( return (
<Link <div key={key}>
key={task.id}
href={ver ? `/client/${token}/review/${ver.id}` : '#'}
onClick={handleReviewClick}
className={cn(
'flex items-center gap-4 p-4 rounded-xl border transition-all group',
'bg-zinc-900 border-zinc-800 hover:border-zinc-600 hover:bg-zinc-800/70',
!ver && 'pointer-events-none opacity-40',
)}
>
<div className="flex-1 min-w-0">
<div className="flex items-center gap-1.5">
<p className="text-sm font-medium text-white">
{task.title}
</p>
<button <button
onClick={(e) => { e.preventDefault(); e.stopPropagation(); copyToClipboard(task.title, `task-${task.id}`); }} className="w-full flex items-center gap-3 px-5 py-2.5 bg-zinc-900/60 hover:bg-zinc-800/60 transition-colors text-left"
className="shrink-0 p-0.5 rounded opacity-0 group-hover:opacity-100 text-zinc-600 hover:text-zinc-300 transition-all" onClick={() => toggleEpisode(key)}
title="Copy task name"
> >
{copiedId === `task-${task.id}` ? ( <ChevronDown
<Check className="h-3 w-3 text-emerald-400" />
) : (
<Copy className="h-3 w-3" />
)}
</button>
</div>
<p className="text-xs text-zinc-500">
{TASK_TYPE_LABELS[task.type] ?? task.type}
</p>
</div>
{ver ? (
<div className="flex items-center gap-3 shrink-0">
{ver.createdAt && (
<span className="text-xs text-zinc-600 hidden sm:block">
{formatDate(ver.createdAt)}
</span>
)}
<span
className={cn( className={cn(
'inline-flex items-center gap-1.5 px-2.5 py-1 rounded-full border text-xs font-medium', 'h-3.5 w-3.5 text-zinc-500 shrink-0 transition-transform duration-200',
approval.className, sceneCollapsed && '-rotate-90',
)} )}
> />
<ApprovalIcon className="h-3 w-3" /> <div className="flex-1 min-w-0">
{approval.label} <span className="text-xs font-medium uppercase tracking-wider text-zinc-400">
{scene === NO_SCENE ? 'No scene' : `Scene ${scene}`}
</span>
<span className="ml-3 text-xs text-zinc-600">
{sceneShots.length}{' '}
{sceneShots.length === 1 ? 'shot' : 'shots'}
</span> </span>
</div> </div>
) : ( {statusPills(sceneShots.flatMap((s) => s.tasks))}
<span className="text-xs text-zinc-600 shrink-0"> </button>
No versions yet {!sceneCollapsed && (
</span> <div className="divide-y divide-zinc-800/60 border-t border-zinc-800/60">
{sceneShots.map(renderShot)}
</div>
)} )}
<ChevronRight className="h-4 w-4 text-zinc-600 group-hover:text-zinc-400 shrink-0 transition-colors" /> </div>
</Link>
); );
})} })
</div> : filteredEpShots.map(renderShot)}
</div>
))}
</div> </div>
)} )}
</div> </div>
@@ -1007,7 +1092,7 @@ export default function ClientPortalPage({
</p> </p>
<button <button
onClick={(e) => { e.preventDefault(); e.stopPropagation(); copyToClipboard(task.title, `task-${task.id}`); }} onClick={(e) => { e.preventDefault(); e.stopPropagation(); copyToClipboard(task.title, `task-${task.id}`); }}
className="shrink-0 p-0.5 rounded opacity-0 group-hover:opacity-100 text-zinc-600 hover:text-zinc-300 transition-all" className="hidden sm:block shrink-0 p-0.5 rounded opacity-0 group-hover:opacity-100 text-zinc-600 hover:text-zinc-300 transition-all"
title="Copy task name" title="Copy task name"
> >
{copiedId === `task-${task.id}` ? ( {copiedId === `task-${task.id}` ? (
+229 -13
View File
@@ -28,12 +28,17 @@ import {
Clock, Clock,
ChevronLeft, ChevronLeft,
ChevronRight, ChevronRight,
ChevronDown,
ChevronUp,
Copy, Copy,
Check, Check,
Download, Download,
Pencil,
Trash2,
} from "lucide-react"; } from "lucide-react";
import { useReviewStore } from "@/hooks/use-review-player"; import { useReviewStore } from "@/hooks/use-review-player";
import { ReviewPasswordGate } from "@/components/clients/ReviewPasswordGate"; import { ReviewPasswordGate } from "@/components/clients/ReviewPasswordGate";
import { HandleBadge } from "@/components/player/HandleBadge";
interface Comment { interface Comment {
id: string; id: string;
@@ -41,7 +46,11 @@ interface Comment {
timestamp: number; timestamp: number;
text: string; text: string;
isResolved: boolean; isResolved: boolean;
/** "WHATSAPP" = client feedback sent by message and logged by the studio */
source?: string | null;
createdAt: string; createdAt: string;
/** This reviewer wrote it, so they can change or remove it. Set by the API. */
canEdit?: boolean;
author: { id: string; name: string | null; image: string | null; email: string }; author: { id: string; name: string | null; image: string | null; email: string };
replies: { id: string; text: string; createdAt: string; author: { name: string | null } }[]; replies: { id: string; text: string; createdAt: string; author: { name: string | null } }[];
} }
@@ -52,6 +61,14 @@ interface Version {
fileUrl: string; fileUrl: string;
fps: number; fps: number;
duration: number | null; duration: number | null;
frameCount?: number | null;
/** High quality review MP4 — the player's quality switch. */
hqFileUrl?: string | null;
/** Where the High Res download comes from: this version's ProRes, or the shot's legacy file. */
highResSource?: "version" | "shot" | null;
handleHead?: number | null;
handleTail?: number | null;
pictureStartFrame?: number | null;
approvalStatus: string; approvalStatus: string;
notes: string | null; notes: string | null;
// Top-level high-res flags (normalised from either shot or task.shot) // Top-level high-res flags (normalised from either shot or task.shot)
@@ -104,6 +121,13 @@ export default function ClientReviewPage({
const [commentFrame, setCommentFrame] = useState<number | null>(null); const [commentFrame, setCommentFrame] = useState<number | null>(null);
const [submittingComment, setSubmittingComment] = useState(false); const [submittingComment, setSubmittingComment] = useState(false);
// Editing / deleting one's own notes
const [editingCommentId, setEditingCommentId] = useState<string | null>(null);
const [editingText, setEditingText] = useState("");
const [savingEdit, setSavingEdit] = useState(false);
const [deletingComment, setDeletingComment] = useState<Comment | null>(null);
const [deleting, setDeleting] = useState(false);
// Approval dialog // Approval dialog
const [approvalDialog, setApprovalDialog] = useState<{ const [approvalDialog, setApprovalDialog] = useState<{
open: boolean; open: boolean;
@@ -209,12 +233,71 @@ export default function ClientReviewPage({
} }
}; };
const beginEditComment = (comment: Comment) => {
setEditingCommentId(comment.id);
setEditingText(comment.text);
};
const cancelEditComment = () => {
setEditingCommentId(null);
setEditingText("");
};
const handleSaveEditedComment = async () => {
const trimmed = editingText.trim();
if (!editingCommentId || !trimmed || !version) return;
setSavingEdit(true);
try {
const res = await fetch(`/api/client/${token}/comment/${editingCommentId}`, {
method: "PATCH",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ text: trimmed }),
});
if (!res.ok) throw new Error("Failed to save note");
cancelEditComment();
await refreshComments(token, version.id);
toast({ title: "Note updated" });
} catch {
toast({ title: "Failed to update note", variant: "destructive" });
} finally {
setSavingEdit(false);
}
};
const handleDeleteComment = async () => {
if (!deletingComment || !version) return;
setDeleting(true);
try {
const res = await fetch(`/api/client/${token}/comment/${deletingComment.id}`, {
method: "DELETE",
});
if (!res.ok) throw new Error("Failed to delete note");
setDeletingComment(null);
// Deleting a drawing note also removes its strokes server-side, and those
// live in the canvas's own state — a full reload remounts the player so
// the frame does not keep showing marks that no longer exist.
loadVersion(token, version.id);
toast({ title: "Note deleted" });
} catch {
toast({ title: "Failed to delete note", variant: "destructive" });
} finally {
setDeleting(false);
}
};
const handleDownloadHighRes = async () => { const handleDownloadHighRes = async () => {
const shotId = version?.highResShotId ?? version?.shot?.id; const shotId = version?.highResShotId ?? version?.shot?.id;
if (!shotId || !token) return; if (!version || !token) return;
const endpoint =
version.highResSource === "version"
? `/api/client/${token}/versions/${version.id}/highres/download`
: shotId
? `/api/client/${token}/shots/${shotId}/highres/download`
: null;
if (!endpoint) return;
setDownloadingHighRes(true); setDownloadingHighRes(true);
try { try {
const res = await fetch(`/api/client/${token}/shots/${shotId}/highres/download`); const res = await fetch(endpoint);
if (!res.ok) throw new Error("Could not get download link"); if (!res.ok) throw new Error("Could not get download link");
const { url } = await res.json(); const { url } = await res.json();
// Open the presigned URL — the Content-Disposition header forces a download // Open the presigned URL — the Content-Disposition header forces a download
@@ -294,9 +377,11 @@ export default function ClientReviewPage({
return ( return (
<div className="flex flex-col h-screen bg-zinc-950 text-white overflow-hidden"> <div className="flex flex-col h-screen bg-zinc-950 text-white overflow-hidden">
{/* Header */} {/* Header */}
<header className="grid grid-cols-[1fr_auto_1fr] items-center gap-2 px-4 py-2.5 border-b border-zinc-800 bg-zinc-900 shrink-0"> {/* Phones: back + shot + prev/next on the first row, status and decision
buttons on a second full-width row. From md: the three-column grid. */}
<header className="flex flex-wrap items-center gap-2 md:grid md:grid-cols-[1fr_auto_1fr] px-4 py-2.5 border-b border-zinc-800 bg-zinc-900 shrink-0">
{/* Left: back + shot path */} {/* Left: back + shot path */}
<div className="flex items-center gap-3 min-w-0"> <div className="flex items-center gap-3 min-w-0 flex-1 md:flex-none">
<Link <Link
href={`/client/${token}`} href={`/client/${token}`}
className="text-zinc-400 hover:text-white transition-colors flex items-center gap-1.5 text-sm shrink-0" className="text-zinc-400 hover:text-white transition-colors flex items-center gap-1.5 text-sm shrink-0"
@@ -324,7 +409,7 @@ export default function ClientReviewPage({
<span className="text-xs text-zinc-500 hidden sm:block">{project?.code}</span> <span className="text-xs text-zinc-500 hidden sm:block">{project?.code}</span>
<span className="text-zinc-600">/</span> <span className="text-zinc-600">/</span>
{contextCode && ( {contextCode && (
<span className="font-mono font-semibold">{contextCode}</span> <span className="font-mono font-semibold truncate">{contextCode}</span>
)} )}
{taskName && ( {taskName && (
<> <>
@@ -354,11 +439,11 @@ export default function ClientReviewPage({
</div> </div>
</div> </div>
{/* Center: status badge + decision buttons */} {/* Center: status badge + decision buttons (their own row on phones) */}
<div className="flex items-center gap-2 shrink-0"> <div className="order-last md:order-none flex w-full md:w-auto items-center gap-2 shrink-0">
<span <span
className={cn( className={cn(
"text-xs px-2.5 py-1 rounded-full border hidden sm:inline-flex items-center gap-1 shrink-0", "text-xs px-2.5 py-1 rounded-full border inline-flex items-center gap-1 shrink-0 mr-auto md:mr-0",
approvalStyle approvalStyle
)} )}
> >
@@ -446,6 +531,11 @@ export default function ClientReviewPage({
comments={comments as any} comments={comments as any}
versionId={version.id} versionId={version.id}
onAddComment={handlePlayerAddComment} onAddComment={handlePlayerAddComment}
handles={version}
hqVideoUrl={version.hqFileUrl}
// The director watches the cut as cut; handles are still one
// toggle away, and flagged whenever the playhead is in one.
defaultEditRangeOnly
saveAnnotationFn={async (data) => { saveAnnotationFn={async (data) => {
const res = await fetch(`/api/client/${token}/annotation`, { const res = await fetch(`/api/client/${token}/annotation`, {
method: "POST", method: "POST",
@@ -479,10 +569,17 @@ export default function ClientReviewPage({
className="flex items-center justify-center h-10 w-full border-b border-zinc-800 hover:bg-zinc-800/60 transition-colors shrink-0" className="flex items-center justify-center h-10 w-full border-b border-zinc-800 hover:bg-zinc-800/60 transition-colors shrink-0"
title={commentsOpen ? "Collapse notes" : "Expand notes"} title={commentsOpen ? "Collapse notes" : "Expand notes"}
> >
{/* Below the video on phones, so down/up there and right/left from md. */}
{commentsOpen ? ( {commentsOpen ? (
<ChevronRight className="h-4 w-4 text-zinc-400" /> <>
<ChevronDown className="h-4 w-4 text-zinc-400 md:hidden" />
<ChevronRight className="h-4 w-4 text-zinc-400 hidden md:block" />
</>
) : ( ) : (
<ChevronLeft className="h-4 w-4 text-zinc-400" /> <>
<ChevronUp className="h-4 w-4 text-zinc-400 md:hidden" />
<ChevronLeft className="h-4 w-4 text-zinc-400 hidden md:block" />
</>
)} )}
{!commentsOpen && ( {!commentsOpen && (
<MessageSquare className="h-4 w-4 text-zinc-400 mt-1" /> <MessageSquare className="h-4 w-4 text-zinc-400 mt-1" />
@@ -510,8 +607,51 @@ export default function ClientReviewPage({
<div className="space-y-3"> <div className="space-y-3">
{comments.map((comment) => ( {comments.map((comment) => (
<div key={comment.id} className="space-y-2"> <div key={comment.id} className="space-y-2">
{editingCommentId === comment.id ? (
// Editing replaces the note in place, so it stays in the
// list at its own frame rather than jumping to a dialog.
<div className="rounded-lg bg-zinc-800/70 p-3 space-y-2">
<div className="flex items-center gap-2">
<span className="text-xs text-zinc-400">Editing note</span>
<span className="ml-auto font-mono text-xs text-amber-400/80">
{frameToTimecode(comment.frameNumber, version.fps)}
</span>
</div>
<Textarea
value={editingText}
onChange={(e) => setEditingText(e.target.value)}
rows={3}
maxLength={5000}
autoFocus
className="bg-zinc-900 border-zinc-700 text-sm resize-none"
onKeyDown={(e) => {
if (e.key === "Enter" && (e.metaKey || e.ctrlKey)) handleSaveEditedComment();
if (e.key === "Escape") cancelEditComment();
}}
/>
<div className="flex gap-2">
<Button
size="sm"
className="h-7 text-xs"
disabled={!editingText.trim() || savingEdit}
onClick={handleSaveEditedComment}
>
{savingEdit ? "Saving…" : "Save"}
</Button>
<Button
size="sm"
variant="ghost"
className="h-7 text-xs"
onClick={cancelEditComment}
disabled={savingEdit}
>
Cancel
</Button>
</div>
</div>
) : (
<div <div
className="rounded-lg bg-zinc-800/70 p-3 space-y-2 cursor-pointer hover:bg-zinc-700/70 transition-colors" className="group rounded-lg bg-zinc-800/70 p-3 space-y-2 cursor-pointer hover:bg-zinc-700/70 transition-colors"
onClick={() => playerRef.current?.seekToFrame(comment.frameNumber)} onClick={() => playerRef.current?.seekToFrame(comment.frameNumber)}
title={`Jump to frame ${comment.frameNumber}`} title={`Jump to frame ${comment.frameNumber}`}
> >
@@ -522,14 +662,46 @@ export default function ClientReviewPage({
</AvatarFallback> </AvatarFallback>
</Avatar> </Avatar>
<span className="text-xs text-zinc-300 font-medium"> <span className="text-xs text-zinc-300 font-medium">
{comment.author.name ?? comment.author.email.split("@")[0]} {comment.source === "WHATSAPP"
? "Client feedback"
: comment.author.name ?? comment.author.email.split("@")[0]}
</span> </span>
<span className="ml-auto font-mono text-xs text-amber-400/80"> <span className="ml-auto font-mono text-xs text-amber-400/80">
{frameToTimecode(comment.frameNumber, version.fps)} {frameToTimecode(comment.frameNumber, version.fps)}
</span> </span>
<HandleBadge frame={comment.frameNumber} />
</div> </div>
<p className="text-sm text-zinc-200 leading-relaxed">{comment.text}</p> <p className="text-sm text-zinc-200 leading-relaxed">{comment.text}</p>
{comment.canEdit && (
// Own notes only. The buttons stop propagation so they
// do not also seek the player to the note's frame.
<div className="flex items-center gap-1 pt-1 opacity-0 group-hover:opacity-100 focus-within:opacity-100 transition-opacity">
<button
type="button"
className="flex items-center gap-1 rounded px-1.5 py-0.5 text-xs text-zinc-400 hover:text-white hover:bg-zinc-700"
onClick={(e) => {
e.stopPropagation();
beginEditComment(comment);
}}
>
<Pencil className="h-3 w-3" />
Edit
</button>
<button
type="button"
className="flex items-center gap-1 rounded px-1.5 py-0.5 text-xs text-zinc-400 hover:text-red-400 hover:bg-zinc-700"
onClick={(e) => {
e.stopPropagation();
setDeletingComment(comment);
}}
>
<Trash2 className="h-3 w-3" />
Delete
</button>
</div> </div>
)}
</div>
)}
{comment.replies.map((reply) => ( {comment.replies.map((reply) => (
<div key={reply.id} className="ml-4 rounded-lg bg-zinc-800/40 border border-zinc-700/50 p-2.5"> <div key={reply.id} className="ml-4 rounded-lg bg-zinc-800/40 border border-zinc-700/50 p-2.5">
<span className="text-xs text-zinc-400 font-medium"> <span className="text-xs text-zinc-400 font-medium">
@@ -546,8 +718,9 @@ export default function ClientReviewPage({
{commentsOpen && commentFrame !== null ? ( {commentsOpen && commentFrame !== null ? (
<div className="border-t border-zinc-800 p-3 space-y-2"> <div className="border-t border-zinc-800 p-3 space-y-2">
<p className="text-xs text-zinc-500 font-mono"> <p className="flex items-center gap-2 text-xs text-zinc-500 font-mono">
Frame {commentFrame} · {frameToTimecode(commentFrame, version.fps)} Frame {commentFrame} · {frameToTimecode(commentFrame, version.fps)}
<HandleBadge frame={commentFrame} />
</p> </p>
<Textarea <Textarea
placeholder="Add your note..." placeholder="Add your note..."
@@ -658,6 +831,49 @@ export default function ClientReviewPage({
</DialogFooter> </DialogFooter>
</DialogContent> </DialogContent>
</Dialog> </Dialog>
{/* Delete confirmation — a note may already have been actioned by the
studio, so removing it is worth one deliberate step. */}
<Dialog
open={!!deletingComment}
onOpenChange={(open) => { if (!open) setDeletingComment(null); }}
>
<DialogContent className="sm:max-w-md">
<DialogHeader>
<DialogTitle>Delete this note?</DialogTitle>
</DialogHeader>
{deletingComment && (
<div className="space-y-2">
<p className="text-xs text-zinc-500 font-mono">
Frame {deletingComment.frameNumber} ·{" "}
{version ? frameToTimecode(deletingComment.frameNumber, version.fps) : ""}
</p>
<p className="rounded bg-zinc-800/70 p-3 text-sm text-zinc-200">
{deletingComment.text}
</p>
<p className="text-xs text-zinc-500">
This removes it for everyone, including the studio. It cannot be undone.
</p>
</div>
)}
<DialogFooter>
<Button
variant="ghost"
onClick={() => setDeletingComment(null)}
disabled={deleting}
>
Cancel
</Button>
<Button
variant="destructive"
onClick={handleDeleteComment}
disabled={deleting}
>
{deleting ? "Deleting…" : "Delete note"}
</Button>
</DialogFooter>
</DialogContent>
</Dialog>
</div> </div>
); );
} }

Some files were not shown because too many files have changed in this diff Show More