Files
Chronos/docs/plans/or1-phase-5.md
T
Alby96andClaude Opus 5.5 86aa07c1d7 docs: plan owner review 1 phase 5
The export panel and Render menu (R3), export options (R8) and the videos
library (R9): design, decisions with defaults, work parcels and tests.

Refs #21

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-05 01:09:51 +01:00

53 KiB
Raw Blame History

Owner review 1, phase 5: export panel and Render menu (R3), export options (R8), videos library (R9), final plan

Context

Owner request. This is docs/requests/2026-10-15-owner-review-1.md, row 5 of the phase table: "R3 export panel and Render menu; R8 export options; R9 videos library (desktop, server API, admin page, copy folder, trash)". Gitea issue #21. It ships as v0.1.0-rc.13 (owner review 3, phase 3 row). Phase 6 (#22: Docker/Unraid/deploy docs, BRIEF §24, full verification) and v1.0.0 (#23) follow.

  • R3, Export menu. "Rivedi il menu di esportazione, così occupa troppo e si capiscono bene i dettagli delle esportazioni". The "non" is missing, so the meaning is: the Export tab and the header's Render menu take too much space and do not make the export details clear. Make them compact and clearer.
  • R8, export options. The Q&A answer, verbatim: "Advanced encoding (rate control, keyframes, B-frames, profile, standard resolutions); fades and hold last frame; reverse, boomerang and loop; single frame".
  • R9, videos library. Q&A: "Desktop + server, one library". Files: "One list; files stay in each sequence's exports/ and can be copied (hash-verified) to a separate videos folder (Docker: a /videos volume). Delete = trash, never erased."
  • Phase 4 answer that still applies. "The chosen proportions win; the preset adapts its resolution (4K at 9:16 = 2160×3840)".
  • Owner review 2 constraints.
    • R6: the admin panel manages and never edits. It does not change project settings and does not start renders. Copying, downloading, deleting into the trash and restoring are management actions.
    • R12: a release at the end of each phase.
    • Project settings are versioned and portable, and older clients keep unknown members through [JsonExtensionData]. A project in a newer format opens read-only.
  • Rules from phase 4 (docs/plans/or1-phase-4.md, DECISIONS rows dated 2026-11-04):
    • A new member that changes pixels or timing is declared after the existing members and omitted at its default.
    • Such a member raises the written format only when it is used.
    • A list of choices is a string, not an enum.
    • Routing format: RenderJobParameters.RequiredSettingsFormat, RegisterNodeRequest.SettingsFormat and ServerInfo.SettingsFormat. Older nodes skip a job they cannot read. On an older server the desktop disables push and render with Tooltips.Server.NeedsNewerServer.

What exists today

Render menu in the editor header

  • src/Chronos.App/Sections/SequenceView.xaml:161-169: v:SplitButton x:Name="RenderButton" bound to RenderText, RenderChoices, SelectedRenderChoice, RenderToolTip and RenderChoiceToolTip. Ctrl+R is set at :55.
  • src/Chronos.App/Editor/EditorViewModel.cs:157: RenderChoices = [.. ExportPresets.BuiltIn.Select(p => new Choice(p.Id, p.NameKey))]. This is a flat list of all 22 built-in presets, with no grouping and no details. It is the "too long" menu.
  • :628: RenderText is "Render · ", so the header widens with long preset names.
  • :597-617: SelectedRenderChoice (read-only sessions keep _renderPreset).
  • :623-660: RenderExport, RenderFormat and RenderBlockedReason.
  • :718-733: RenderAsync(priority, batch) goes through Session.RenderRequests(export).
  • src/Chronos.Ui/Visuals/SplitButton.cs:117-124: the menu is a ContextMenu with ItemTemplate and DisplayMemberPath only. It has no separators, submenus or two-line items.

Export step

  • src/Chronos.App/Editor/EditorMeasures.xaml:275-314: the measure area (PrefersTallMeasure = true, ExportTab.cs:488) is a UniformGrid of 118 px preset cards (CardColumns). Each card shows name, Recommended chip, Format, Encoding, Estimate and a batch checkbox. The cards for 22 presets take most of the tall area.
  • src/Chronos.App/Editor/EditorPanels.xaml:374-581: the Output panel is a flat 11-row grid:
    • Container, Codec, Resolution W×H with aspect, Output size (phase 4, :460-463), Frame rate with Auto/Reset, Quality, Encoder with kind, Colour depth, File name, Save to, Sync;
    • an estimate card (Size, Time, Result) and the Notices list;
    • a four-row footer: Add to queue with Batch…, Render now (36 px), the history line (History link, Reveal, Send again, Not sent, HistoryText), the "Save project file" link and the Restore settings split button.
  • src/Chronos.App/Editor/ExportTab.cs (762 lines):
    • Codecs (:114-120) and the commands (:139-153);
    • Width/Height EditableFields (:148-149, LoadBox :574-579);
    • OutputSizeText (:287-302), FrameRates/Auto (:307-321) and Quality (Mb/s or 1–100, :324-345);
    • Encoders (:347-368) and Depths (:370-386);
    • HistoryText (:427-429), HasUnsent/SendAgain (:431-465), EstimateCardsAsync (:636-664), EditOverrides/EditExport (:729-733) and ValidateSize 16..16384.
  • Not shown anywhere today: rate control, keyframe interval, B-frames, profile, frame count, output duration.

Encoding values already modelled end to end

  • ExportOverrides (src/Chronos.Core/Project/ProjectSettings.cs:237-256) already holds Profile, BitRate, GopFrames, BFrames, Quality, RateControl and Encoder.
  • ExportResolver.Resolve applies them: it parses RateControl and keeps the GOP in seconds when the fps changes. Matches includes them, so editing one makes the export "Custom".
  • EncodeSettings (src/Chronos.Core/Video/Encoding.cs) carries them.
  • The Media Foundation session honours them (MediaFoundationEncoderSession.cs:205-218, 265-286).
  • So advanced encoding needs UI only. Nodes from phase 4 and earlier already read these members, so the format does not go up.
  • Standard resolutions: ExportPresets.Resolutions (src/Chronos.Core/Export/ExportPreset.cs:120-124, 720p…8K) is described as "offered in the Custom editor", but no UI offers it. RenderSize.Of (src/Chronos.Core/Render/RenderSize.cs) already adapts a W×H box to the chosen proportions (box turned to portrait below a ratio of 1). A standard resolution is therefore just a Width/Height override.

Not modelled at all: fades, hold, reverse, boomerang, loop, single frame

  • RenderPlan.Build (src/Chronos.Core/Render/RenderPlan.cs:199-260) emits PlannedFrames (From/To/Fraction/Duration90k/Slots/Held/Interpolated).
  • RenderRun (src/Chronos.Core/Render/RenderPipeline.cs:200-228) loops over _plan.Frames, with StarTrails/Median/Mean stacking in plan order.
  • EmitAsync (:404-434) calls FrameFinish.Apply(frame, look, knee). FrameFinish works in linear light (src/Chronos.Core/Render/FrameFinish.cs:9-14, ImageBuffer linear float).
  • RenderSetup.Workload() and Estimate() count Plan.Frames.
  • GIF writes NETSCAPE2.0 with loop forever, and APNG writes num_plays 0, so those two already loop forever in the viewer.
  • ImageSequenceSession (src/Chronos.Core/Video/Managed/ManagedSessions.cs:211-) writes a folder <stem>_000001.ext. No session writes a single still file.

Renders and the "library"

  • The renders table is in src/Chronos.Data/Migrations/{sqlite,postgres}/0001_initial.sql:100-115. 0009_projects.sql added project/version. The latest migration is 0009.
  • There is no hash and no kind column. The Render entity (src/Chronos.Core/Model/Entities.cs:146-167) has no Sha256.
  • RenderRepository offers Insert/Get/ListBySequence (newest first)/Delete/RebaseFolder. Insert and Delete recount sequences.rendered_count.
  • Renders are index-only (not in sidecars). Render ids are preserved across sync, and RenderJobHandler.RenderId is deterministic per job and entry.
  • On the server, renders are listed per sequence only:
    • GET /api/v1/sequences/{id}/renders (src/Chronos.Server/Api/SequenceEndpoints.cs:51, 394-398);
    • the file at GET /api/v1/renders/{id}/file (FileEndpoints.cs:35, 115-122);
    • the panel's sequence page section "Renders" with a download link (src/Chronos.Server/Admin/web/pages/library/sequence.js:89-91, 417-450).
  • No endpoint, panel page or desktop view lists all videos.
  • Nothing deletes a single render except internal code. Nothing copies a render elsewhere.
  • Trash: .chronos/trash/ holds sequences (<name>.json records), trash/photos/ and replaced files. TrashKind {Sequence, Photos, Replaced} is at src/Chronos.Data/Archiving/SequenceTrash.cs:53-63, ListAsync at :213-231.
    • EmptyTrash (JobKind 18) works with a fingerprint and .pending journals.
    • /archive/trash endpoints (ManageArchive, src/Chronos.Server/Api/TrashEndpoints.cs).
    • The panel's pages/library/trash.js (kindLabel/restoreTip :222-227).
  • JobKind (src/Chronos.Core/Model/Enums.cs:64-124) ends at WorkspaceMove = 23, so the next free value is 24.
  • ServerCapabilities (src/Chronos.Protocol/Dtos.cs:31-38) has only Projects.
  • RenderDto (src/Chronos.Protocol/Sequences.cs:119-131) has no hash or kind.
  • Server paths: ServerOptions has CHRONOS_ARCHIVE_PATH and CHRONOS_SPACE_PATH (src/Chronos.Server/Configuration/ServerOptions.cs:41-42). There is no videos path. The compose file mounts only /archive (deploy/docker/docker-compose.yml:79), and so does the Unraid template (deploy/unraid/chronos.xml:28).
  • Desktop sections: SectionKey {Library, Import, Edit, Archive, Jobs, Server, Settings} (src/Chronos.App/Shell/SectionViewModel.cs:6-17), with Ctrl+1…6 in src/Chronos.App/MainWindow.xaml:18-30. There is no Videos section.
  • Bug found while reading: ProcessingJobs.BatchExport (src/Chronos.Data/Processing/ProcessingJobs.cs:186-187) builds a new ExportSettings with only Preset, NameTemplate and Folder. Any new export member (playback) would be dropped from batch renders.
  • Second bug: ProcessingJobs.Parameters (:190-200) computes the format from settings, the project's own export, rather than from the job's export. Once export members raise the format this would under-route.
  • BRIEF §8.6: only SHFormatDrive, ShellExecute("open", url) and ShellExecute("explore", folder) are allowed. The desktop cannot hand a video to the system player. Playback has to be in-process (WPF MediaElement, Windows Media Foundation, the same OS component family the encoder already uses). MediaPlayer is used today only in tests (DECISIONS:270).

Chosen approach (summary)

  • R3.
    • The header button becomes "Render ▾". Its tooltip carries the full details.
    • The menu becomes short and structured: Recommended, batch, recent, "Other presets ›" grouped by preset group, Save frame ›, Add to queue, Videos.
    • The Export step replaces the card grid with a compact, grouped preset table whose columns are the details: size, codec, fps, estimated size and estimated time.
    • The Output panel becomes four collapsible groups (Output, Encoding, Playback, File) with a one-line summary when collapsed.
    • A sticky footer holds a summary line, Render now, Add to queue, Batch (n) and the Videos (n) link.
  • R8.
    • Encoding is UI over the existing overrides: no format change, and older nodes stay compatible.
    • Playback (direction, loops, fades, hold) is a new export.playback section, format 3, applied by a Core OutputProgram between RenderPlan and the encoder.
    • Single frame is a still render job (format-3-gated) launched from "Save frame ›".
  • R9.
    • Migration 0010_videos.sql adds renders.sha256, renders.kind and render_copies.
    • One VideoLibrary service in Data (list, delete into trash, restore, copy with hash verification), backed by a VideoCopy = 24 job and a trash/videos/ area.
    • Server: /api/v1/videos endpoints and the capability videos.
    • Panel: a Videos page.
    • Desktop: a Videos section that merges local and server videos.
    • The videos folder is a desktop setting and a server setting (CHRONOS_VIDEOS_PATH, /videos volume).

Decisions to record (docs/DECISIONS.md rows dated 2026-11-05, added in P0)

  1. Render ▾ without the preset name.
    • The header button reads "Render" (Ctrl+R) and keeps a fixed width.
    • Its tooltip gives the preset, size, codec, fps, estimated size and time, and the blocked reason when there is one.
    • The menu's checked item shows the current preset.
    • This supersedes "Render · preset" (EditorViewModel.cs:628).
  2. Render menu contents, in this order.
    • Recommended preset; the batch presets; up to 3 recent presets (from this sequence's render history); "Other presets ›" submenu grouped by ExportPreset.Group (Video, Social, Intermediate, Sequence, Web).
    • Separator, then Render batch (n), Add to queue, Save frame ›, Videos of this sequence.
    • Each preset item has a muted details line (size · codec · fps). Estimates are not shown in the menu, because they cost a plan per preset.
  3. Preset table replaces the preset cards in the Export measure area.
    • One 28 px row per preset, grouped, with collapsible group headers.
    • Columns: batch ☐, Name (+ Recommended chip), Size, Codec, fps, Est. size, Est. time.
    • Clicking a row selects the preset. The checkbox adds it to the batch.
    • This supersedes the card grid (DECISIONS:149).
  4. Collapsible setting groups are a new DESIGN §4 pattern.
    • The header is the group name (Text.Body 600) with a chevron and, when collapsed, a muted one-line summary of the values.
    • Collapse state is kept per group in app settings (not in the project).
    • Defaults: Output open, Encoding collapsed, Playback collapsed, File open.
  5. Export footer.
    • The footer stays fixed below the scrolling groups.
    • Summary line: " · ·
    • Buttons: Render now (primary), Add to queue, Batch (n).
    • Links: Videos (n), Reveal, Send again / Not sent.
    • "Save project file" moves to the project ▾ menu. "Restore settings" moves into the File group as a row.
    • This supersedes DECISIONS:188 placement.
  6. Advanced encoding uses the existing overrides. No format raise.
    • Rate control is VBR/CBR/Quality (H.264, HEVC, AV1 only). Bit rate shows for VBR/CBR, Quality 1–100 for Quality.
    • Keyframes are entered in seconds (0.5–10, step 0.5, or Auto = the preset's) and stored as GopFrames = round(s × fps).
    • B-frames are 0–4 or Auto. They are disabled with a reason for Baseline, MJPEG, GIF, APNG and the image sequences.
    • Profile lists only the profiles the codec and depth allow: H.264 Baseline/Main/High; HEVC Main (8-bit) or Main 10 (10-bit); AV1 Main only (row disabled).
    • Any edit makes the export "Custom" (BRIEF §11.4, unchanged).
  7. Standard resolutions form the Resolution choice.
    • Choices: Preset, Source, 720p, 1080p, 1440p, 4K UHD, DCI 4K, 5K, 6K, 8K, Custom.
    • A standard choice writes the landscape box into Overrides.Width/Height. RenderSize.Of then fits the chosen proportions, so proportions win (4K at 9:16 gives 2160×3840).
    • Custom shows the W×H fields from phase 4.
  8. Playback section, settings format 3.
    • It is export.playback, an object omitted when everything is at its default: { direction: "forward"|"reverse"|"boomerang", loops: 1..10, fadeIn: s, fadeOut: s, holdEnd: s }.
    • Each member is omitted at its default (forward, 1, 0, 0, 0).
    • ProjectSettings.CurrentVersion = 3. RequiredFormat = 3 when Export.Playback is non-default, otherwise the phase 4 rule.
    • Playback lives in the export, so batch presets inherit it.
  9. Output program. OutputProgram.Build(plan, playback, frameRate) turns the plan into the emitted sequence of (plan index, duration90k, fade gain).
    • Reverse is the plan reversed.
    • Boomerang is forward then backward, without repeating the turning frame.
    • Loops repeat the pass. From the second pass a boomerang starts at its second frame, so the joint frame is not doubled.
    • Hold extends the last emitted frame by holdEnd.
    • Held frames inside a fade are split per slot, so the gain changes smoothly.
    • Fades longer than half of the program are scaled to fit, with warning Export.Render.FadesShortened.
    • Each loop is rendered again, not cached, so render time multiplies by the loop count. The estimate shows this.
  10. Fade colour. A fade goes to and from black.
    • The gain is applied after the look and knee (the last FrameFinish step), in linear light.
    • Gain = SrgbToLinear(t), so the fade looks even.
    • The preview step's "Preview 10 s" does not play fades (Q4).
  11. Stacking with reverse.
    • Window stacks (median, mean) are per frame and simply play in program order.
    • Star trails accumulate in program order, so reversed trails grow from the end.
    • Boomerang with star trails is disabled with a reason (Tooltips.Export.BoomerangStack) (Q5).
  12. Single frame ("Save frame ›").
    • Choices: PNG, JPEG, TIFF 16-bit.
    • It renders the frame under the preview's cursor at the export's output size, with every correction (camera, exposure, look, knee). It applies no playback.
    • Job parameters gain StillFrame (sequence frame index) and StillPhoto (the photo's sha256, the identity that wins when both are given). RequiredSettingsFormat = 3, so an older node never claims a still job and renders a whole video by mistake.
    • The file is named from the export's name template + " - " + the 1-based frame number in 4 digits.
    • It is recorded as a render with kind = "still", fps 0 and duration 0.
    • Routing follows Session.RenderRequests (local, server, workspace).
  13. Migration 0010 (sqlite and postgres):
    • renders.sha256 TEXT NULL;
    • renders.kind TEXT NULL (null = video or image sequence, told apart by the codec; "still");
    • ix_renders_created (created);
    • table render_copies (id, render_id, path, sha256, bytes, copied_at, copied_by) with no FK to renders, so a copy of a server video downloaded to the PC is recorded too.
  14. Hash at completion.
    • Every new single-file render is hashed (sha256) when it is recorded: RenderJobHandler, workspace render ledger, workspace send filing, render uploads (which already carry sha256).
    • Image-sequence folders keep sha256 = null. They are verified file by file when copied.
    • Older renders are hashed lazily the first time they are copied, deleted or restored.
  15. Videos folder.
    • Desktop: Settings › Archive › "Videos folder", default %USERPROFILE%\Videos\Chronos.
    • Server: setting videosPath, locked by CHRONOS_VIDEOS_PATH. Docker: /videos volume, unset by default, and copy is disabled with reason videos_folder_unset.
    • A videos folder inside the archive root or the workspace is refused.
    • The folder is flat. A name collision gets " (2)" (the ExportNaming rule).
  16. Copy is a job: JobKind.VideoCopy = 24 ("video-copy"), desktop and server, at the IO priority level.
    • Steps:
      1. check free space;
      2. copy to .incoming-<id>.part in the target folder and flush;
      3. hash the copy and compare it with the source's sha256 (hash the source first when null);
      4. rename without overwrite, then record render_copies.
    • A mismatch deletes the part file and fails the item.
    • The source is never touched.
    • On the desktop, a server-only video is copied by downloading it through ISyncRemote.DownloadRenderAsync.
  17. Delete = trash.
    • POST …/videos/delete with dryRun: true returns the plan: items, bytes, blocked items (a running send/upload/copy of the render, or a missing file) and a fingerprint. The real call must carry the same fingerprint.
    • A deleted video moves into .chronos/trash/videos/<render id>-<utc ticks>/ with a record trash/videos/<entry>.json (render row, original path, sha256, sequence id/title, deleted by, deleted at). The move happens under the sequence lease with a .pending journal (same pattern as FrameTrash).
    • The renders row is removed and rendered_count recounted.
    • Copies in the videos folder are not touched. The confirmation says so.
    • A render whose file is missing is shown as Missing, and Delete removes only its row (still dry-run first).
    • The trash entry name is videos-<render id>-<ticks>, and TrashKind.Videos lists as "videos".
    • Records live under trash/videos/, so older builds never read them as sequence records.
  18. Restore.
    • Re-hash the trashed file and compare it with the record. Refuse on mismatch (trash_hash_mismatch).
    • Move it back to its folder, with a free name if the original is taken.
    • Re-insert the row with the same render id.
    • Restore fails with a clear error when the sequence is gone (it must be restored first).
    • EmptyTrash includes video entries in its fingerprint.
  19. Server API.
    • /api/v1/videos: list (Read), get (Read), delete plan and delete (Delete, audited), copy (Edit, audited).
    • Restore uses the existing /archive/trash/{name}/restore (ManageArchive).
    • ServerCapabilities.Videos = "videos". Without it, the desktop's Videos section shows local videos only and greys the server group out with a reason.
    • RenderDto gains Sha256 and Kind (trailing, optional).
  20. Desktop Videos section.
    • A new rail section after Edit, shortcut Ctrl+4. Archive, Jobs and Server move to Ctrl+5…7, and Settings stays Ctrl+, (Q1).
    • It shows local archive renders, the signed-in server's videos and the workspace's unsent renders, de-duplicated by render id (a synced render shows "Here and on server").
    • Workspace renders are read-only rows (Play, Show in folder, Send).
  21. Desktop playback runs in-process in a player pane inside the Videos view, not a dialog. It uses WPF MediaElement for MP4/MOV (H.264/HEVC where Windows has the decoder) and an image view for stills and GIF/APNG.
    • When the system cannot decode the file, the pane says "Cannot play here", and Show in folder stays available.
    • No external process (BRIEF §8.6) (Q2).
  22. Admin panel Videos page.
    • It is a sidebar page after Library.
    • It offers list and cards, filters, sort, multi-select, Copy to videos folder, Delete… (dry-run dialog), Download, and Play in an HTML5 <video> dialog (the session cookie authorises the GET).
    • Restore goes through the Library › Trash view (kind "Videos").
    • No editing and no rendering (owner review 2, R6).

Settings schema (format 3)

"export": {
  "preset": { "auto": false, "value": "4k-hevc10" },
  "overrides": { "rateControl": "cbr", "bitRate": 60000000, "gopFrames": 30, "bFrames": 0, "profile": "hevcmain10", "width": 3840, "height": 2160 },
  "nameTemplate": "{date} {title} - {preset}",
  "batch": ["1080p-h264"],
  "syncToServer": false,
  "playback": { "direction": "boomerang", "loops": 2, "fadeIn": 1.0, "fadeOut": 1.5, "holdEnd": 2.0 }   // new, omitted at defaults
}
// ProjectSettings.cs: declared after SyncToServer, before Extra
public sealed record PlaybackSettings
{
    public string? Direction { get; init; }   // null = "forward"; "reverse", "boomerang"; unknown values render forward with warning Export.Render.DirectionUnknown
    public int? Loops { get; init; }          // null = 1; clamped 1..10
    public double? FadeIn { get; init; }      // seconds, null = 0; clamped 0..30
    public double? FadeOut { get; init; }
    public double? HoldEnd { get; init; }     // seconds, null = 0; clamped 0..60
    [JsonIgnore] public bool IsDefault => …;
    [JsonExtensionData] public Dictionary<string, JsonElement>? Extra { get; set; }
}
public PlaybackSettings? Playback { get; init; }   // in ExportSettings; null when IsDefault (normalised on write)
  • CurrentVersion = 3. RequiredFormat = Export.Playback is { IsDefault: false } ? 3 : (phase 4 rule).
  • Advanced encoding stays in overrides: no new member and no format change.
  • Render job parameters gain trailing members: int? StillFrame = null, string? StillPhoto = null. RenderRules.RequiredFormat returns 3 for still jobs. The overload takes a still flag, or ProcessingJobs raises it.

Pipeline order (with R8)

  1. RenderPlan.Build (unchanged).
  2. OutputProgram.Build(plan, export.Playback, fps) produces ProgramEntry(PlanIndex, Duration90k, Gain), plus DurationSeconds and Count.
  3. RenderRun renders entries in program order:
    • The default mode, the window stack and interpolation use plan.Frames[entry.PlanIndex].
    • Star trails accumulate in program order.
    • PreparedFrameCache (4 frames) is reused as it is. A boomerang's turn and the loops re-render.
  4. Emit: FrameFinish.Apply(frame, look, knee), then FrameFinish.Fade(frame, gain) when gain < 1, then the encoder with entry.Duration90k.
  5. RenderResult.DurationSeconds and FrameCount come from the program. RenderSetup.Workload() and Estimate() use program.Count × per-frame cost (loops multiply the time).

Still: RenderRun.RenderStillAsync(planIndex) renders one plan frame (From = To = index, no interpolation, no blur) → FrameFinish.Apply → StillImageSession (one file, written to a temp file then committed with AtomicFile.Commit like SingleFileSession).

UI

Editor header and Render menu (P5)

  • RenderButton content = Editor.Render ("Render"). The tooltip is Tooltips.Editor.RenderDetails with the values: preset · W×H · codec depth · fps · ~size · ~time · Ctrl+R, plus the blocked reason when blocked.
  • SplitButton gains hierarchical menu support: items of type RenderMenuItem {Kind: Preset|Header|Separator|Command|Submenu, Label, Details, IsChecked, Command, Children, ToolTip}, styled as two-line MenuItem templates in Chronos.Ui/Themes/Visuals.xaml.
  • Menu items (decision 2). Every item has a tooltip.
  • "Save frame ›" offers PNG, JPEG and TIFF 16-bit. It is disabled with a reason when:
    • no frame is under the cursor;
    • the session is read-only;
    • the server is older (NeedsNewerServer, format 3).
  • "Videos of this sequence" navigates to Videos filtered by this sequence.
  • The project ▾ menu (SequenceView ContextMenu ~:130-135) gains "Save project file" bound to Editor.Export.SaveProjectCommand.

Export step (P6)

┌ measure area (tall) ──────────────────────────────────────────────────┐
│ ▾ Video                                                               │
│ ☐ 4K HEVC 10-bit [Recommended]  3840×2160  HEVC 10  30  ~1.2 GB  4 min│
│ ☑ 1080p H.264                   1920×1080  H.264 8  30  ~310 MB  1 min│
│ ▸ Social (4)   ▸ Intermediate (3)   ▸ Sequence (4)   ▸ Web (3)         │
└───────────────────────────────────────────────────────────────────────┘
┌ Output panel (scrolls) ──────────────────────┐
│ ▾ Output                                      │ Container, Codec, Resolution (standard ▾ / W×H),
│                                               │ Output size, Frame rate (+Auto), Colour depth
│ ▸ Encoding   VBR · 40 Mb/s · 1 s · B 2 · High │ Encoder, Rate control, Bit rate | Quality,
│                                               │ Keyframes, B-frames, Profile
│ ▸ Playback   Forward · no fades               │ Direction, Loops, Fade in, Fade out, Hold end
│ ▾ File                                        │ File name, Save to, Sync, Restore settings
│ Notices                                       │
├ footer (fixed) ───────────────────────────────┤
│ 2026-09-28 Harbour sunset - 4K….mp4           │
│ ~1.2 GB · ~4 min · 0:42 · 1 260 frames        │
│ [ Render now ]  [Add to queue] [Batch (2)]    │
│ Videos (3) · Reveal · Send again              │
└───────────────────────────────────────────────┘
  • Rows use the phase 4 SettingRows conventions: label ≤ 3 words, tooltip on every control, a Reset on overridden values.
  • Rows that do not apply are disabled with a tooltip reason, not hidden: B-frames for Baseline, Rate control for managed codecs, and Playback "Loops" for a still. They follow the Encoder row's existing pattern.
  • Fade in/out and Hold use numeric sliders, 0–10 s step 0.5. Exact entry uses the EditableField pattern.
  • Direction: Forward / Reverse / Boomerang. Boomerang is disabled with a reason for star trails.
  • The estimate updates on every playback change (time × loops, duration including holds).

Videos section, desktop (P7)

  • Toolbar: Search, Kind (All / Videos / Stills / Sequences), Codec, Year, Source (All / This PC / Server / Not sent), Sort (Newest, Oldest, Largest, Title), a view toggle (Grid/List), and the selection count.
  • Grid: cards with poster (the sequence's cover thumbnail, or the still itself), title, preset name, W×H · codec · duration · size, date, and state chips (Here, On server, Copied, Missing, Not sent).
  • Item actions (toolbar for the selection, context menu per item):
    • Play: opens the right-hand player pane;
    • Show in folder;
    • Copy to videos folder (local), or Download to videos folder (server-only);
    • Copy on server (server videos, Edit permission);
    • Delete… (dry-run, then confirm dialog, as decision 17);
    • Open in Edit.
  • Empty states: "No videos" and "Server not reachable" (local still shown).
  • The Export footer's "Videos (n)" and the Render menu item open the section filtered by sequence.
  • Settings › Archive gains the "Videos folder" row (Browse, Open) with tooltips.
  • The Archive trash dialog (src/Chronos.App/Archive/TrashDialogViewModel.cs) lists kind "Videos" with Restore.

Admin panel (P4)

  • New page pages/videos.js, sidebar entry after Library (icon videos).
  • Same filters, sort and cards/list as the desktop.
  • Selection toolbar: Download (single), Copy to videos folder (disabled with reason when the folder is unset or there is no Edit permission), Delete… (dry-run modal listing items and bytes, blocked items, "copies in the videos folder stay").
  • Play: a <video controls> modal for mp4/mov/webm; an <img> for stills, GIF and APNG; a download link otherwise.
  • The sequence page's Renders section gains kind and hash columns and an "All videos" link (#videos?sequence=<id>).
  • trash.js handles "videos" in kindLabel, restoreTip and the restore message.
  • Settings page: a read-only "Videos folder" row with lockedBy (CHRONOS_VIDEOS_PATH) when locked, editable otherwise. It is a server setting, not a project edit.

Icons (P0)

branding/ui-icons/icons.py → regenerate Icons.xaml and icons.js: videos (film strip library), play, copy-to-folder, still-frame, fade, boomerang.

String keys (en / it; labels ≤ 3 words; every control has a tooltip; P0 adds them all)

Key en it
Editor.Render Render Esporta
Editor.RenderMenu.Recommended Recommended Consigliato
Editor.RenderMenu.Recent Recent Recenti
Editor.RenderMenu.Other Other presets Altri preset
Editor.RenderMenu.Batch Render batch Esporta gruppo
Editor.RenderMenu.SaveFrame Save frame Salva fotogramma
Editor.RenderMenu.Videos Videos Video
Export.Group.Output / Encoding / Playback / File Output / Encoding / Playback / File Uscita / Codifica / Riproduzione / File
Export.RateControl / .Vbr / .Cbr / .Quality Rate control / Variable / Constant / Quality Controllo bitrate / Variabile / Costante / Qualità
Export.Keyframes Keyframes Fotogrammi chiave
Export.BFrames B-frames Fotogrammi B
Export.Profile Profile Profilo
Export.Resolution.Standard / .Preset / .Source / .Custom Resolution / Preset / Source / Custom Risoluzione / Preset / Origine / Personalizzata
Export.Direction / .Forward / .Reverse / .Boomerang Direction / Forward / Reverse / Boomerang Direzione / Avanti / Indietro / Boomerang
Export.Loops Loops Ripetizioni
Export.FadeIn / FadeOut / HoldEnd Fade in / Fade out / Hold end Dissolvenza in / Dissolvenza out / Pausa finale
Export.Footer.Videos Videos ({0}) Video ({0})
Export.Render.FadesShortened / DirectionUnknown (warnings) (avvisi)
Shell.Section.Videos Videos Video
Videos.Play / ShowInFolder / Copy / Download / CopyOnServer / Delete / OpenInEdit … …
Videos.State.Here / OnServer / Copied / Missing / NotSent … …
Videos.Kind.Video / Still / Sequence … …
Settings.Archive.VideosFolder Videos folder Cartella video
Jobs.Kind.VideoCopy Copy videos Copia video
Archive.Trash.Kind.Videos Videos Video
Errors.Videos.FolderUnset / FolderInsideArchive / HashMismatch / NoSpace / SequenceGone / Fingerprint … …
Tooltips.* one per control above, including the disabled reasons (Tooltips.Export.BFramesNA, .RateControlNA, .BoomerangStack, .StillNeedsFrame, Tooltips.Videos.*) …
Admin.Videos.* page title, filters, buttons, modal texts …

Server API and compatibility

Endpoint Perm Body / result
GET /api/v1/videos?q&kind&codec&year&sequence&source&sort&cursor&limit Read VideoPageDto { items: VideoDto[], next }. VideoDto = RenderDto members + sequenceTitle, sequenceFirstCapture, projectName, projectVersionNumber, state ("ok"/"missing"), copies[] (path, copiedAt).
GET /api/v1/videos/{id} Read VideoDto
POST /api/v1/videos/delete Delete { ids[], dryRun, fingerprint? } → VideoDeletePlanDto { items, bytes, blocked[], fingerprint }, or 409 plan_changed. Audited.
POST /api/v1/videos/copy Edit { ids[] } → { jobId }, or 409 videos_folder_unset. Audited.
GET /api/v1/renders/{id}/file Read unchanged. Check that Range requests are served for <video> seeking, and add them in FileResponses.Serve if missing.
/archive/trash ManageArchive unchanged routes. IsEntryName accepts videos-<guid>-<ticks>, and kind gains "videos".

Server settings DTO gains videosPath (+ lockedBy). ServerInfo.Capabilities adds "videos", and SettingsFormat becomes 3 automatically (ProjectSettings.CurrentVersion).

Compatibility matrix:

Pair Behaviour
New desktop, older server (SettingsFormat 2, no "videos") Format-3 pushes and renders are disabled (NeedsNewerServer). Save frame is disabled for server sequences. The Videos section lists local renders only, and the server source is greyed out with a reason.
Older desktop, new server A format-3 project opens read-only (existing rule). Its manifest renders carry the unknown sha256 and kind, which are ignored.
Older node, new server Never claims format-3 jobs (playback or still).
New desktop/server, DB at 0009 Migration 0010 adds nullable columns and the table. No backfill, hashes come lazily.
Older build reading the archive trash/videos/ is never listed. Older EmptyTrash ignores it, so it grows until a new build empties it (CHANGELOG note).

Packages

P0 lands first and alone. P1–P7 then run in parallel, each owning only the files listed. P8 (integration) and P9 (docs) come last. A file created or edited by P0 is afterwards owned by the parcel named next to it.

P0: Groundwork (contracts, schema, protocol, enums, migration, strings, icons, decisions)

  • Files
    • src/Chronos.Core/Project/ProjectSettings.cs: PlaybackSettings, ExportSettings.Playback, CurrentVersion = 3, RequiredFormat, normalisation of default playback to null, ProjectJson registration.
    • src/Chronos.Core/Model/Enums.cs: JobKind.VideoCopy = 24, appended.
    • src/Chronos.Core/Model/Entities.cs: Render.Sha256, Render.Kind, RenderCopy.
    • src/Chronos.Protocol/Jobs.cs: RenderJobParameters.StillFrame, StillPhoto.
    • src/Chronos.Protocol/Sequences.cs: RenderDto.Sha256, Kind.
    • new src/Chronos.Protocol/Videos.cs with its DTOs, plus the ProtocolJson context registration.
    • src/Chronos.Protocol/Dtos.cs: ServerCapabilities.Videos.
    • src/Chronos.Protocol/Client/ChronosClient.cs: ListVideosAsync, GetVideoAsync, PlanDeleteVideosAsync, DeleteVideosAsync, CopyVideosAsync.
    • new src/Chronos.Data/Migrations/sqlite/0010_videos.sql and postgres/0010_videos.sql.
    • new src/Chronos.Data/Videos/IVideoLibrary.cs: interface, VideoQuery, VideoItem, VideoDeletePlan, VideoCopyParameters, with a NotImplemented stub implementation registered so P3 and P7 compile.
    • new src/Chronos.Core/Render/OutputProgram.cs: public API (ProgramEntry, Build) with a forward-only body (P1 completes it).
    • i18n/en/*.resx and i18n/it/*.it.resx: every key of this phase.
    • branding/ui-icons/icons.py + generated Icons.xaml and icons.js.
    • docs/DECISIONS.md: decisions 1–22.
    • tests/fixtures/settings/format3-playback.json.
  • Tests
    • ProjectSettings round trip: default playback omitted, format 1/2/3 stamping, a format-3 file read by a format-2 reader keeps playback in Extra (fixture).
    • Migration 0010 applies on sqlite and postgres (Data.Tests migration test).
    • DTO JSON shapes.
  • Done when the solution builds, all suites pass and the i18n check is green.

P1: Core output program, fades, still (Core only)

  • Files
    • src/Chronos.Core/Render/OutputProgram.cs (complete);
    • RenderPipeline.cs (program iteration, fade, RenderStillAsync);
    • RenderSetup.cs (workload and estimate from the program, still setup);
    • RenderResult.cs, RenderModels.cs (RenderTarget.StillFrame);
    • FrameFinish.cs (Fade);
    • RenderRules.cs (format 3 for playback or still);
    • src/Chronos.Core/Video/Encoding.cs (EncodeSettings.SingleImage);
    • src/Chronos.Core/Video/Managed/ManagedSessions.cs + managed provider (StillImageSession);
    • src/Chronos.Core/Export/ExportNaming.cs (still name);
    • Core estimate types.
  • Depends on P0.
  • Tests (tests/Chronos.Core.Tests/Render/)
    • Program: forward/reverse/boomerang × loops 1–3 indices; no doubled turning frame; hold duration; fades over held slots; fades scaled with warning; total duration exact in 90 kHz ticks.
    • Pipeline with a synthetic source: frame count and duration in RenderResult; the fade gain on the first and last frame is ~0 (black) and the middle unchanged; star trails reversed; still writes exactly one PNG/JPEG/TIFF16 at the output size.
    • RenderRules.RequiredFormat returns 3.
  • Done when the Core tests pass and the self-test is green.

P2: Data: hashing, routing fixes, video library, trash, copy job

  • Files
    • src/Chronos.Data/Repositories/RenderRepository.cs (columns, ListPageAsync, SetSha256Async); new RenderCopyRepository.cs.
    • src/Chronos.Data/Processing/Jobs/RenderJobHandler.cs (hash, still targets, kind).
    • src/Chronos.Data/Processing/ProcessingJobs.cs:
      • BatchExport copies Playback and NameTemplate/Folder (fixes the dropped-member bug);
      • Parameters/Routed/RequiredFormat use settings with { Export = export };
      • Still(...) request builder.
    • SequenceRender.cs, ManagedRenderJobHandler.cs, RenderNodeClient.cs (node still support and its settings format 3).
    • src/Chronos.Data/Workspaces/WorkspaceRenderJobHandler.cs, the workspace renders ledger (sha256, kind), WorkspaceSendJobHandler.cs.
    • new src/Chronos.Data/Videos/VideoLibrary.cs (replaces the P0 stub), VideoTrash.cs, VideoCopyJobHandler.cs, VideosFolder.cs (validation, free space, collision names).
    • src/Chronos.Data/Archiving/SequenceTrash.cs (TrashKind.Videos, listing), SequenceTrash.Empty.cs, ArchiveService.cs (restore dispatch, handler registration), Jobs/EmptyTrashJobHandler.cs.
    • src/Chronos.Data/Jobs/JobPriorityQueue.cs (VideoCopy level).
  • Depends on P0. Uses P1's RenderRules/Still API through the P0 signatures. If P1 is not merged yet, its tests use the forward stub.
  • Tests (tests/Chronos.Data.Tests/Videos/)
    • List paging and filters on sqlite.
    • Dry-run fingerprint changes when a render is added.
    • Delete moves the file and the row, recounts and writes the journal. A crash mid-move (journal present) resumes on the next start.
    • Restore keeps the id and verifies the hash. A tampered file is refused.
    • Missing-file delete removes the row only.
    • Copy: verified, collision " (2)", mismatch cleans up the part, not enough space fails before writing, a folder inside the archive is refused, an image-sequence folder is verified per file.
    • BatchExport keeps playback.
    • Routing: a playback job gets format 3, and an older node (format 2) does not claim it.
    • Still job end to end.
  • Done when the Data tests pass on sqlite (postgres in CI).

P3: Server API, settings, deploy

  • Files
    • new src/Chronos.Server/Api/VideoEndpoints.cs.
    • src/Chronos.Server/Hosting/ServerHost.cs (map it).
    • src/Chronos.Server/Api/SystemEndpoints.cs (capability).
    • TrashEndpoints.cs (entry names).
    • SequenceEndpoints.cs (RenderDto sha/kind; upload complete records sha256/kind).
    • FileEndpoints.cs / FileResponses (Range if missing).
    • src/Chronos.Server/Configuration/ServerOptions.cs (VideosPath, CHRONOS_VIDEOS_PATH).
    • ServerSettingsStore.cs, server settings DTOs in Api/Dto.cs.
    • deploy/docker/docker-compose.yml (${CHRONOS_VIDEOS:-./videos}:/videos, env), deploy/docker/Dockerfile (create /videos), deploy/unraid/chronos.xml (Videos path config, optional).
  • Depends on P0. Integrates P2's service at merge.
  • Tests (tests/Chronos.Server.Tests/)
    • Permissions per endpoint (Read/Delete/Edit, 403s).
    • Delete without the matching fingerprint gives 409.
    • Copy without a folder gives 409 videos_folder_unset.
    • Audit rows written.
    • Server info lists "videos" and SettingsFormat 3.
    • Trash list and restore of a video entry through the existing routes.
    • Range GET on a render file.
    • ChronosClient video methods against the test host.
  • Done when the server tests pass.

P4: Admin panel

  • Files
    • new src/Chronos.Server/Admin/web/pages/videos.js;
    • app.js (pages list :10-12, nav);
    • pages/library/trash.js, pages/library/sequence.js, pages/settings.js;
    • admin.css.
  • Depends on P0 (DTOs, strings, icons).
  • Tests
    • Panel tests in Chronos.Server.Tests: page module loads, every t() key exists in Admin.resx, no edit/render endpoints called from videos.js.
    • Manual pass in the browser against a dev server (play, delete dry-run, copy disabled reason, trash restore).
  • Done when the panel tests pass and the manual pass is recorded in the PR.

P5: Desktop header and Render menu

  • Files
    • src/Chronos.App/Editor/EditorViewModel.cs (menu model, RenderText/Tooltip, Save frame commands, recent presets).
    • new src/Chronos.App/Editor/RenderMenu.cs.
    • src/Chronos.App/Editor/EditorSession.cs (StillRequests).
    • src/Chronos.App/Editor/ServerJobs.cs (format 3 gate for still and playback).
    • src/Chronos.App/Sections/SequenceView.xaml (+ .xaml.cs) (button, project ▾ "Save project file").
    • src/Chronos.Ui/Visuals/SplitButton.cs and src/Chronos.Ui/Themes/Visuals.xaml (hierarchical two-line menu items).
  • Depends on P0. Calls P2's ProcessingJobs.Still through the P0 signature.
  • Tests (Chronos.App.Tests)
    • The menu model groups presets and marks the current one. Recent presets come from history.
    • Save frame is disabled with the right reason (read-only, no frame, older server).
    • Still requests carry the frame index and the photo sha.
    • The Render tooltip contains the size and codec.
    • Header width is constant across presets in all 38 languages (the 1200 px check from phase 3a).
  • Done when the App tests (filtered) pass.

P6: Desktop Export step

  • Files
    • src/Chronos.App/Editor/ExportTab.cs;
    • EditorPanels.xaml (Export template only);
    • EditorMeasures.xaml (Export measure);
    • ExportPlanner.cs, CardColumns.cs (remove the Export use if unused elsewhere);
    • EditorSettings.cs (group collapse state);
    • SettingRows.cs (if new row kinds are needed);
    • EditorStyles.xaml (collapsible group style);
    • new src/Chronos.App/Editor/ExportGroups.cs (group summaries), new src/Chronos.App/Editor/PresetTable.cs (rows and groups).
  • Depends on P0. Uses P1's program-based estimate when merged, and stub estimates before that.
  • Tests
    • Rate control/B-frames/Profile availability per codec and depth.
    • Keyframes seconds↔frames on an fps change.
    • A standard resolution with 9:16 shows 2160×3840 in Output size.
    • Playback edits raise the project format to 3 and set the read-only gate for older servers.
    • Summary text.
    • Group collapse persisted.
    • Batch (n) count.
    • The Videos (n) link navigates with a sequence filter.
  • Done when the App tests pass and xaml-lint is clean.

P7: Desktop Videos section

  • Files
    • new src/Chronos.App/Sections/VideosView.xaml(.cs), VideosViewModel.cs, src/Chronos.App/Videos/VideoSources.cs (local + server + workspace merge), VideoPlayerPane.xaml(.cs).
    • src/Chronos.App/Shell/SectionViewModel.cs (SectionKey.Videos), ShellViewModel.cs (TopSections), MainWindow.xaml (Ctrl+4…7), SectionTemplates.xaml.
    • src/Chronos.App/Sections/SettingsViewModel.cs and SettingsView.xaml (Videos folder row), the app settings model (VideosFolder).
    • src/Chronos.App/Archive/TrashDialogViewModel.cs (videos kind).
    • src/Chronos.App/Jobs/JobNotices.cs (VideoCopy).
  • Depends on P0. Integrates P2 and P3 at merge.
  • Tests
    • Merge and de-duplicate by render id.
    • Older server shows local only with the reason.
    • Filters and sort.
    • Delete flow calls the dry run first and shows bytes and blocked items.
    • A copy with the folder unset gives the reason.
    • Ctrl+4 opens Videos and Ctrl+5 opens Archive.
    • The player pane falls back to "Cannot play here".
  • Done when the App tests pass.

P8: Integration (captures, sample data, translations, prune, review)

  • Files
    • src/Chronos.App/Shell/ScreenCapture.cs;
    • src/Chronos.App/DesignTime/SampleData.cs (renders with sha/kind, a still, a copied video, a missing one, a videos trash entry, a workspace unsent render);
    • the 36 other languages' resx;
    • tests/visual/baselines/*;
    • fixes from the review round.
  • Scenes to add (dark and light):
    • edit-export (re-baselined) and edit-export-encoding (Encoding open);
    • edit-export-playback (Playback open, boomerang + fades);
    • edit-render-menu (menu open with "Other presets ›" expanded);
    • edit-export-rtl;
    • videos, videos-list, videos-player, videos-delete (confirmation), videos-remote-old (older server reason);
    • settings-archive (re-baselined, Videos folder);
    • archive-trash (re-baselined, a Videos entry).
  • Panel screenshots for docs/ui: Videos page, Play modal, delete plan, trash with videos.
  • Done when
    • screenshots diff is clean after acceptance;
    • i18n check passes in 38 languages;
    • i18n prune removes the keys this phase made obsolete (Editor.RenderWithPreset, card strings);
    • the package guard, pe-check and self-test are green;
    • one adversarial review round has run and its findings are fixed.

P9 (last): Docs and release

  • BRIEF:
    • §5 (Render entity: sha256, kind, render copies);
    • §7 (trash/videos/, videos folder);
    • §11.3–11.5 (output program, playback, fades, still, advanced encoding, standard resolutions, export UI);
    • §12.1 (Videos rail section and shortcuts);
    • §12.3 (Export step layout, Render menu);
    • new §12.x Videos library;
    • §14.3 (videos endpoints, RenderDto);
    • §14.6 (VideoCopy job);
    • §14.8 (panel Videos page, trash kind);
    • §14.9 (settings videosPath, CHRONOS_VIDEOS_PATH);
    • §24 amendments rows.
  • DESIGN §4 (collapsible group, preset table, two-line menu items), docs/ui/mockups/Export.html (new layout), new Videos.html and AdminVideos.html.
  • ARCHITECTURE: output program, video library, trash areas.
  • CHANGELOG [Unreleased]:
    • migration 0010;
    • settings format 3 upgrade note (older desktops open such projects read-only; update nodes before using playback or still);
    • /videos volume.
  • STATUS row 8.x. The request file's row 5 is set to done with the commit.
  • Release v0.1.0-rc.13 (issue #21).

Merge order: P0, then P1 and P2, then P3, then P5, P6 and P7 in any order, then P4, P8 and P9. P1 and P2 merge before P5 and P6 so the real estimates and still builder replace the stubs.

Verification

  • dotnet build Chronos.slnx -c Release.
  • dotnet run --project tests/Chronos.Core.Tests -- --junit out.xml, and the same for Data, Server, Tools and Core.Windows.
  • App tests filtered on the PC.
  • Chronos.Tools: i18n check, xaml-lint, package-guard (zero PackageReference), pe-check, selftest.
  • Chronos.exe --capture + screenshots diff.
  • A real render on the PC:
    • 4K HEVC CBR, GOP 1 s, B 0, boomerang × 2 with 1 s fades and a 2 s hold. Check its duration in Windows' file properties and play it in the Videos pane.
    • A PNG still.
    • Copy to the videos folder (hash verified, " (2)" on repeat), then delete into trash and restore (same id).
  • Docker: compose with /videos. Copy from the panel, check the audit log.

How to try it

  • Edit › Export. Open Encoding and set CBR, then open Playback and set Boomerang. Render now.
  • Render ▾ › Save frame › PNG.
  • Ctrl+4 opens Videos. Use Play, Copy to videos folder, then Delete… and restore from Archive › Maintenance › Trash.
  • Panel: Videos page.
# Question Default
Q1 Videos as its own rail section (shortcuts shift) or as a view inside Library? Own section after Edit, Ctrl+4. The shortcut shift goes in the CHANGELOG.
Q2 Desktop playback: in-process MediaElement pane, or Show in folder only? MediaElement pane with the "Cannot play here" fallback. No external process.
Q3 Header Render button: "Render" only, or a short preset label? "Render" only, with details in the tooltip and the checked menu item.
Q4 Should "Preview 10 s" play the program (fades, reverse)? No, not this phase. The preview stays forward.
Q5 Reverse/boomerang with star trails? Reverse accumulates in program order. Boomerang is disabled with a reason.
Q6 Maximum loops and fade/hold ranges? Loops 1–10, fades 0–30 s (slider 0–10), hold 0–60 s (slider 0–10).
Q7 Still formats: include linear DNG? PNG, JPEG and TIFF 16-bit only.
Q8 Still file name? <expanded template> - 0123.<ext> (1-based frame number).
Q9 Workspace (unsent) renders in Videos? Yes, read-only rows with the "Not sent" chip.
Q10 "Remove copy" from the videos folder? Not this phase. Copies are user files, and Chronos never deletes them.
Q11 Videos folder layout? Flat, " (2)" on collisions. No per-sequence subfolders.
Q12 Default desktop videos folder? %USERPROFILE%\Videos\Chronos (Environment.SpecialFolder.MyVideos). Server: unset.
Q13 Hash old renders proactively? No, lazily on copy, delete or restore.
Q14 Permission for server copy? Edit (as render uploads, DECISIONS:300). Delete needs Delete, restore needs ManageArchive.

Risks

  • Ownership collisions. EditorPanels.xaml and EditorMeasures.xaml belong to P6 only. P5 touches SequenceView.xaml and SplitButton/Visuals.xaml only. All resx files belong to P0 (later P8), and ProjectSettings.cs to P0 only. A parcel that needs a new string asks P0's owner or adds it during P8 integration, never in parallel.
  • Format 3 fan-out. Every older desktop opens playback projects read-only, and every older node skips those jobs. Mitigation: playback is omitted at defaults, so ordinary projects stay format 1/2. CHANGELOG upgrade note.
  • Routing bug carry-over. If BatchExport/Parameters are not fixed (P2), batch presets silently lose fades and older nodes might get playback jobs. P2 has tests for both.
  • Render time with loops and boomerang (full re-render per pass). The estimate shows it. Caching encoded passes is a later optimisation.
  • Encoder honouring of CBR, GOP and B-frames varies by hardware MFT. Keep the phase 4 "encoder limits" warnings. Record the actual values in RenderResult warnings when the MFT rejects them.
  • MediaElement codec availability (HEVC needs the Store extension). The fallback text and Show in folder cover it, and the test is the pane's state, not decoding.
  • Hashing large renders adds a sequential read at completion. Report it as a "Verifying" stage in progress.
  • Trash moves across volumes (an export folder outside the archive root, ExportSettings.Folder). Use copy, hash, then delete with a journal, and test this path.
  • Index rebuild. Renders and copies are index-only. Check whether Archive › Rebuild drops them as today. If it does, the Videos library loses entries after a rebuild: document it, or have rebuild keep the renders/render_copies tables.
  • Panel <video> and Range. Without Range support, seeking fails. P3 verifies.
  • Header and footer cut at 1200 px in long languages: the P5/P6 tests across 38 languages.

Critical Files for Implementation

  • B:\Altro\BalboSoft\Chronos.claude\worktrees\or1-p4\src\Chronos.App\Editor\ExportTab.cs
  • B:\Altro\BalboSoft\Chronos.claude\worktrees\or1-p4\src\Chronos.App\Editor\EditorViewModel.cs
  • B:\Altro\BalboSoft\Chronos.claude\worktrees\or1-p4\src\Chronos.Core\Render\RenderPipeline.cs
  • B:\Altro\BalboSoft\Chronos.claude\worktrees\or1-p4\src\Chronos.Data\Processing\ProcessingJobs.cs
  • B:\Altro\BalboSoft\Chronos.claude\worktrees\or1-p4\src\Chronos.Data\Archiving\SequenceTrash.cs