feat(app): Edit opens workspace projects, with versions, sync and the project menu

Owner review 2, phase 5a (R8), desktop package: editing moves out of the library. A sequence of this PC's archive
now opens in Edit as a project of the workspace (%LOCALAPPDATA%\Chronos\workspace, .\data\workspace when portable),
with this PC's archive as its home; the editor writes the workspace's working state, never the library.

- WorkspaceHost composes WorkspaceStore and WorkspaceSync over Settings > Workspace's folder: checkout and the
  WorkspaceCopy job, status, Save version with the sync after it (Sync automatically, on by default), sync (pull,
  then push), conflicts, restore, history, new / rename / delete project, and Remove local copy, which refuses
  while work is unsent unless the user sends it first or discards it, reads back the home's head and base and
  checks their hashes, and keeps discarded work in <workspace>/.trash; versions past Kept versions are pruned only
  once the home returns them with the same content.
- WorkspaceSequenceSource: frames and pixels of the media (proxies), the working state saved atomically under the
  project's lease and merged against the basis, the home's deep report while its frames are the media's, renders
  at the home with the portable settings recording the project and the version.
- Edit: the project opened last for the sequence, else "Open in workspace" (Main made from the sequence's settings,
  another project or a new one; proxies) checks out, copies and opens once the copy is done. The picker lists the
  workspace's projects with their state above the library. The title's project menu: Save version (Ctrl+S, note),
  Sync, History (compare, restore as one undo step), New project, Rename, Delete project, Remove local copy; a
  conflict dialog only on real conflicts (keep mine, take the library's, save both, later); Update media when the
  library's frames moved. .chronos files: format 2 opens its project, format 1 gives its settings to Main.
- Settings > Workspace: folder (shown, Open), Sync automatically, Kept versions. Strings in English and Italian.
- A capture (sample data without an engine) keeps editing the library.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit da47a580ba9db3ce2a1db2f11c30cf7344c8b394)
This commit is contained in:
Alby96 committed 2026-10-27 22:53:05 +01:00
1 parent 03d32f18d3
commit b9d1c396a1
37 files changed
+4547 -104

No files matched your search

@@ -0,0 +1,342 @@
using System.IO;
using System.Text.Json;
using Chronos.Core.Advice;
using Chronos.Core.Analysis;
using Chronos.Core.Analysis.Deep;
using Chronos.Core.Archiving;
using Chronos.Core.Diagnostics;
using Chronos.Core.Export;
using Chronos.Core.Imaging;
using Chronos.Core.Localization;
using Chronos.Core.Model;
using Chronos.Core.Project;
using Chronos.Core.Render;
using Chronos.Data;
using Chronos.Data.Archiving;
using Chronos.Data.Archiving.Jobs;
using Chronos.Data.Jobs;
using Chronos.Data.Processing;
using Chronos.Data.Projects;
using Chronos.Data.Workspaces;
using Chronos.Protocol;
namespace Chronos.App.Editor;
/// <summary>A source whose renders are made otherwise than from the project as the editor holds it (a workspace project: at its home).</summary>
public interface IProjectRenders
{
/// <summary>The jobs that render <paramref name="export"/> of <paramref name="project"/> (the editor's settings, positions on the source's frames).</summary>
IReadOnlyList<ArchiveJobRequest> RenderRequests(Sequence sequence, ProjectSettings project, ExportSettings export, int sourceWidth, int sourceHeight);
}
/// <summary>
/// A workspace project open in the editor (owner review 2, R8: editing happens in the workspace, never inside the
/// library): the frames and pixels of the media the workspace holds (<c>media/media.json</c>, the proxies), the project
/// from its working state (<c>project.chronos</c>, positions placed on those frames), saved there atomically under the
/// project's lease and merged against the basis like <see cref="LocalSequenceSource"/> (a pull or a copy job writes it
/// too). Jobs run on this PC's engine against the home's sequence (same id): an analysis reads the home's originals, a
/// render renders the home's originals with the project's portable settings and records the project and the version
/// (<see cref="RenderRequests"/>). The deep report is the home's while its frames are the media's, else the copy the
/// workspace took. A copy job that changed the media (Update media) makes saves made against the frames read before refused
/// (<see cref="FramesChangedException"/>) until the editor has read them again and moved its positions by frame.
/// </summary>
public sealed class WorkspaceSequenceSource : ISequenceSource, IProjectRenders
{
private const int JobsListed = 200;
private readonly WorkspaceSync _sync;
private readonly ChronosDatabase _db;
private readonly ImageDecoder _decoder;
private readonly JobEngine? _engine;
private readonly Lock _gate = new();
private readonly List<IRenderFrameSource> _retired = [];
private IRenderFrameSource? _frames;
private IFrameSource? _pixels;
private int _frameCount;
private int _framesVersion = -1;
private Guid[] _frameIds = [];
private FramePhotos _photos = new([]);
private BundleWorkspace? _workspace;
private bool _readOnly;
private int _disposed;
public WorkspaceSequenceSource(WorkspaceSync sync, Guid projectId, ChronosDatabase db, ImageDecoder decoder, JobEngine? engine)
{
ArgumentNullException.ThrowIfNull(sync);
ArgumentNullException.ThrowIfNull(db);
ArgumentNullException.ThrowIfNull(decoder);
_sync = sync;
_db = db;
_decoder = decoder;
_engine = engine;
ProjectId = projectId;
if (engine is not null) engine.JobChanged += OnJobChanged;
}
public Guid ProjectId { get; }
/// <summary>The project's folder in the workspace.</summary>
public WorkspaceProject Project => _sync.Store.Project(ProjectId);
/// <summary>The workspace section of the project file as read last (name, Main, home, base, media); null before the first read.</summary>
public BundleWorkspace? Workspace => Volatile.Read(ref _workspace);
/// <summary>The frames version of the home the media read last were copied at; -1 before the first read.</summary>
public int MediaFramesVersion => Volatile.Read(ref _framesVersion);
/// <summary>The photos of the media read last, in frame order (what positions name).</summary>
public FramePhotos Photos => Volatile.Read(ref _photos);
public bool IsRemote => false;
/// <summary>Settings of a newer Chronos: shown, never saved.</summary>
public bool IsReadOnly => Volatile.Read(ref _readOnly);
public bool IsOutdated => false;
/// <summary>A workspace project's read-only state is known when it opens.</summary>
public event Action? ReadOnlyChanged
{
add { }
remove { }
}
public event Action<Job>? JobChanged;
/// <exception cref="EditorException">The workspace holds no media for the project (copy them again), or the project is gone.</exception>
public async Task<SequenceContent> LoadAsync(CancellationToken cancellationToken)
{
WorkspaceSession session;
try
{
session = await _sync.OpenAsync(ProjectId, cancellationToken);
}
catch (InvalidOperationException ex)
{
throw new EditorException(Loc.L("Errors.Workspace.NotCheckedOut"), ex);
}
catch (InvalidDataException ex)
{
throw new EditorException(Loc.L("Editor.Error.Project"), ex);
}
if (session is not { Sequence: { } media, Media: { } index }) throw new EditorException(Loc.L("Errors.Workspace.MediaMissing"));
var home = session.Bundle.Workspace!.Home;
var row = await _db.Sequences.GetAsync(home.SequenceId, cancellationToken);
var archive = row is null ? null : await _db.Archives.GetAsync(row.ArchiveId, cancellationToken);
IReadOnlyList<Render> renders = row is null ? [] : await _db.Renders.ListBySequenceAsync(home.SequenceId, cancellationToken);
return await Task.Run(() =>
{
var frames = media.Frames;
Swap(media, index, session.Bundle.Workspace!, session.IsReadOnly);
var times = frames.Where(f => f.CapturedAt is not null).Select(f => f.CapturedAt!.Value).Order().ToList();
// The home's row (camera, interval, tags) with the frames this workspace holds.
var sequence = (row ?? media.Sequence) with
{
FrameCount = frames.Count,
FramesVersion = index.FramesVersion,
FirstCapture = times.Count > 0 ? times[0] : null,
LastCapture = times.Count > 0 ? times[^1] : null,
SettingsJson = session.Working.ToJson(),
};
var folder = archive is null ? null : new ArchivePaths(archive.RootPath).Sequence(row!.Folder);
var (deep, otherFrames) = ReadReport(folder, row?.FramesVersion == index.FramesVersion, session.Project.AnalysisPath, frames.Count);
var context = SequenceContext.FromFrames(frames);
return new SequenceContent(sequence, frames, session.Working, LightAnalyzer.Analyze(frames), deep, context.SourceWidth, context.SourceHeight,
folder?.Exports, [.. renders.OrderByDescending(r => r.Created)], [])
{
DeepOfOtherFrames = otherFrames,
};
}, cancellationToken);
}
/// <remarks>Only a copy job changes the workspace's frames (Update media): its media index is compared with the one read last.</remarks>
public Task<bool> FramesCurrentAsync(CancellationToken cancellationToken) => Task.Run(() =>
{
var (framesVersion, ids) = (Volatile.Read(ref _framesVersion), Volatile.Read(ref _frameIds));
try
{
return Project.ReadMedia() is { } media && media.FramesVersion == framesVersion && media.Frames.Select(f => f.Id).SequenceEqual(ids);
}
catch (InvalidDataException ex)
{
Log.Warning("editor", $"The media index of workspace project {ProjectId} cannot be read", ex);
return false;
}
}, cancellationToken);
/// <summary>Whether the home's frames moved past those the workspace holds (frames added or removed there): "Update media" copies them again.</summary>
public async Task<bool> HomeFramesChangedAsync(CancellationToken cancellationToken)
{
if (Workspace is not { } workspace || MediaFramesVersion < 0) return false;
return await _db.Sequences.GetAsync(workspace.Home.SequenceId, cancellationToken) is { } row && row.FramesVersion != MediaFramesVersion;
}
public async ValueTask<ImageBuffer?> DecodeAsync(int index, int maxLongEdge, DecodePurpose purpose, CancellationToken cancellationToken)
{
IFrameSource? pixels;
int count;
lock (_gate) (pixels, count) = (_pixels, _frameCount);
if (pixels is null || (uint)index >= (uint)count) return null;
// The loader decodes synchronously: an async delegate keeps a superseded decode's cancellation in user code (R4).
return await Task.Run(async () => await pixels.LoadAsync(index, maxLongEdge, cancellationToken).ConfigureAwait(false), cancellationToken);
}
/// <exception cref="EditorException">The project is read-only, or its media are gone.</exception>
/// <exception cref="FramesChangedException">The media changed since they were read (a copy job): read them again first.</exception>
public Task<ProjectSettings> SaveProjectAsync(ProjectSettings project, ProjectSettings basis, CancellationToken cancellationToken)
{
ArgumentNullException.ThrowIfNull(project);
ArgumentNullException.ThrowIfNull(basis);
var framesVersion = Volatile.Read(ref _framesVersion);
if (framesVersion < 0) throw new InvalidOperationException("LoadAsync first.");
var folder = Project;
return Task.Run(async () =>
{
using (await folder.LockAsync(_sync.LockWait, cancellationToken))
{
var bundle = folder.ReadBundle();
if (bundle.IsReadOnly || project.IsNewerFormat) throw new EditorException(Loc.L("Errors.Workspace.ReadOnly"));
var media = folder.ReadMedia() ?? throw new EditorException(Loc.L("Errors.Workspace.MediaMissing"));
// A copy job moved the working state onto other frames: the editor reads them and moves its positions first.
if (media.FramesVersion != framesVersion) throw new FramesChangedException(Loc.L("Errors.Workspace.MediaChanged"));
var stored = ProjectSettings.FromJson(ProjectContent.Place(bundle.Project.ToJson(), media.Photos), allowNewer: true);
var merged = ProjectMerge.SameValues(stored, basis) ? project : ProjectMerge.Merge(basis, project, stored);
if (ProjectMerge.SameValues(merged, stored)) return merged;
folder.WriteBundle(bundle with { Project = merged, Saved = DateTimeOffset.UtcNow });
return merged;
}
}, cancellationToken);
}
public async Task<Guid> SubmitAsync(ArchiveJobRequest request, CancellationToken cancellationToken)
{
if (_engine is null) throw new InvalidOperationException(Loc.L("Editor.Error.NoEngine"));
var job = await _engine.EnqueueAsync(request, cancellationToken: cancellationToken);
return job.Id;
}
public async Task<IReadOnlyList<Job>> ListJobsAsync(CancellationToken cancellationToken) =>
(await _db.Jobs.ListAsync(null, JobsListed, null, cancellationToken)).Items;
public Task CancelJobAsync(Guid jobId, CancellationToken cancellationToken) =>
(_engine ?? throw new InvalidOperationException(Loc.L("Editor.Error.NoEngine"))).CancelAsync(jobId, cancellationToken);
public Task RetryJobAsync(Guid jobId, CancellationToken cancellationToken) =>
(_engine ?? throw new InvalidOperationException(Loc.L("Editor.Error.NoEngine"))).ResumeAsync(jobId, cancellationToken);
/// <summary>
/// The render at the home (owner review 2, R8: edit with proxies, render where the originals are): one job of this PC's
/// engine per preset, with the project's portable settings (positions parked by photo, placed on the home's frames by
/// the render) and the project recorded on the render; the version too when the settings are those of the last
/// version saved (an unsaved working state renders as it is, without a version).
/// </summary>
public IReadOnlyList<ArchiveJobRequest> RenderRequests(Sequence sequence, ProjectSettings project, ExportSettings export, int sourceWidth, int sourceHeight)
{
ArgumentNullException.ThrowIfNull(sequence);
ArgumentNullException.ThrowIfNull(project);
ArgumentNullException.ThrowIfNull(export);
var portable = ProjectContent.ToPortable(project with { Export = export }, Photos);
var hash = ProjectContent.Hash(portable);
var (tipId, tipHash) = Tip();
var version = new ProjectVersion
{
Id = tipId ?? Guid.Empty,
ProjectId = ProjectId,
Number = 0,
SettingsJson = portable,
ContentHash = hash,
};
var requests = ProcessingJobs.RenderVersion(sequence, version, export, sourceWidth, sourceHeight);
if (tipId is not null && string.Equals(tipHash, hash, StringComparison.OrdinalIgnoreCase)) return requests;
return [.. requests.Select(r => r with { ParametersJson = WithoutVersion(r.ParametersJson) })];
}
public async ValueTask DisposeAsync()
{
if (Interlocked.Exchange(ref _disposed, 1) == 1) return;
if (_engine is not null) _engine.JobChanged -= OnJobChanged;
List<IRenderFrameSource> sources;
lock (_gate)
{
sources = [.. _retired];
if (_frames is not null) sources.Add(_frames);
_retired.Clear();
(_frames, _pixels) = (null, null);
}
foreach (var source in sources)
{
if (source is IAsyncDisposable disposable) await disposable.DisposeAsync();
}
}
/// <summary>
/// Takes the media read now: a frame source over them when they differ from those read before (the old one is disposed
/// with this source, as a decode may still read it), their frames and photos, the project's workspace section.
/// </summary>
private void Swap(WorkspaceSequence media, WorkspaceMedia index, BundleWorkspace workspace, bool readOnly)
{
var ids = media.Frames.Select(f => f.Id).ToArray();
lock (_gate)
{
if (_frames is null || index.FramesVersion != _framesVersion || !ids.AsSpan().SequenceEqual(_frameIds))
{
if (_frames is not null) _retired.Add(_frames);
_frames = media.OpenFrames(_decoder);
_pixels = (IFrameSource)_frames;
_frameCount = media.Frames.Count;
}
_frameIds = ids;
_framesVersion = index.FramesVersion;
_photos = index.Photos;
_workspace = workspace;
_readOnly = readOnly;
}
}
/// <summary>The last version saved: the newest one not sent yet, else the base; with its content hash.</summary>
private (Guid? Id, string? Hash) Tip()
{
try
{
if (_sync.Unpushed(ProjectId) is { Count: > 0 } unsent) return (unsent[^1].Id, unsent[^1].ContentHash);
return Project.ReadBundle().Workspace?.Base is { } basis ? (basis.VersionId, basis.ContentHash) : (null, null);
}
catch (Exception ex) when (ex is IOException or InvalidDataException or InvalidOperationException)
{
Log.Warning("editor", $"The versions of workspace project {ProjectId} cannot be read; the render names none", ex);
return (null, null);
}
}
private static string? WithoutVersion(string? parametersJson)
{
if (parametersJson is null || JsonSerializer.Deserialize(parametersJson, ProtocolJson.Default.RenderJobParameters) is not { } parameters) return parametersJson;
return JsonSerializer.Serialize(parameters with { ProjectVersionId = null }, ProtocolJson.Default.RenderJobParameters);
}
/// <summary>
/// The deep report the editor shows: the home's while its frames are the workspace's, else the copy the workspace took;
/// whether one of another number of frames was read instead.
/// </summary>
private static (DeepAnalysisReport? Report, bool OtherFrames) ReadReport(SequencePaths? home, bool sameFrames, string copied, int frameCount)
{
var otherFrames = false;
foreach (var path in new[] { sameFrames ? home?.AnalysisPath : null, copied })
{
if (path is null || !File.Exists(path)) continue;
try
{
var report = DeepAnalysisReport.Load(path);
if (report.FrameCount == frameCount) return (report, false);
otherFrames = true;
}
catch (Exception ex) when (ex is IOException or InvalidDataException or JsonException or UnauthorizedAccessException)
{
Log.Warning("editor", $"{path} cannot be read", ex);
}
}
return (null, otherFrames);
}
private void OnJobChanged(Job job) => JobChanged?.Invoke(job);
}