refactor!: rename Titano to Chronos and move CI and releases to Gitea (#6)
CI / Build and test (push) Successful in 8m14s
CI / Windows tests and installer (push) Skipped
CI / YAML check (push) Successful in 7s
Release / Build, test and publish (push) Successful in 13m19s
CI / PostgreSQL 16 integration (push) Successful in 4m49s
CI / PostgreSQL 17 integration (push) Successful in 5m28s
CI / Docker image (push) Successful in 53s
Release / Server image (push) Failing after 10s

The owner renamed the product and moved the repository to the self-hosted
Gitea (https://gitea.encke-hake.ts.net/BalboSoft/Chronos) for more control,
and asked for Actions and a first automatic release with the server package
and the Windows exe (docs/requests/2026-10-23-chronos-gitea.md).

- Chronos everywhere: a byte-exact rename of contents and paths, then a
  per-language review of the forms the old name's ending had dictated.
- Gitea instead of GitHub: the update check, licence, issue and support
  links read ChronosReleasesUrl; the update check takes the highest stable
  version, offers a pre-release build its final release and reports a
  repository it cannot see as a failed check. EULA, security policy and
  Gitea issue forms live at the repository root.
- Gitea Actions for the Linux act_runner (.gitea/workflows): CI, release,
  nightly image and performance gates in the .NET SDK container with git
  checkout and the system SQLite. The release cross-compiles the Windows
  programs, checks their icon, version and DPI manifest, packs installers
  and zips, publishes the Gitea release and pushes the server image
  (REGISTRY_TOKEN). Windows-only tests run in an opt-in job on a Windows
  runner (WINDOWS_RUNNER).
- New Chronos.Tools commands: zip, gitea-release, postgres-ci (replaces the
  docker-exec script, which Gitea's service containers do not allow; the
  throw-away server runs without durability) and pe-check.
- Timed tests take their budget from TestTiming (CHRONOS_TEST_TIME_FACTOR,
  3 on the shared runner; the weekly performance gates keep theirs).

BREAKING CHANGE: programs, settings, data folders, file types, environment
variables and the Docker image use the new name; nothing is migrated from
Titano, which never had a release.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: Alberto Balbo <alberto.balbo.96@gmail.com>
This commit was merged in pull request #6.
This commit is contained in:
Alby96andClaude Opus 5.5 authored and Alby96 committed 2026-10-23 12:45:18 +02:00
1 parent c99842cc86
commit f2b58522b9
1801 files changed
+11804 -10676

No files matched your search

+422
View File
@@ -0,0 +1,422 @@
using Chronos.Core.Advice;
using Chronos.Core.Diagnostics;
using Chronos.Core.Export;
using Chronos.Core.Project;
using Chronos.Core.Video;
using Chronos.Data.Archiving.Jobs;
using Chronos.Data.Processing;
namespace Chronos.App.Editor;
/// <summary>
/// One sequence open in the editor (BRIEF §12.3): its content, the advisor's view of it (§10.3), the project with undo
/// and redo, and the actions of every section — edit, Optimise (§10.4), Reset, exclusions and hero, analysis and render
/// jobs. Every change is saved shortly after it is made (<see cref="ProjectSaver"/>); a change stored meanwhile by
/// someone else (an analysis job, another client) is merged in. On a server sequence, settings both sides changed to
/// different values wait for the user's choice (<see cref="Conflict"/>). Frames inserted under the editor (a sync
/// download, an import of earlier photos, a scan) are read again before the next save or render, and the project's frame
/// positions, its undo steps included, move with their frames as the stored ones did. Call from one thread (the UI thread).
/// </summary>
public sealed class EditorSession : IAsyncDisposable
{
public static readonly TimeSpan DefaultSaveDelay = TimeSpan.FromMilliseconds(400);
/// <summary>Times a save reads the frames again when frames keep changing under it.</summary>
private const int FollowAttempts = 3;
/// <summary>Sections "Optimise all" walks through, in panel order.</summary>
public static IReadOnlyList<AdvisorSection> OptimisedSections { get; } =
[AdvisorSection.Frames, AdvisorSection.Timing, AdvisorSection.Exposure, AdvisorSection.Motion, AdvisorSection.Camera, AdvisorSection.Export];
private readonly IReadOnlyList<EncoderCapability> _codecs;
private readonly ProjectSaver _saver;
private ProjectSettings _basis;
/// <summary>
/// The sequence being read again (<see cref="BeginReadAsync"/>) until its content is taken: saves and other reads wait
/// for it.
/// </summary>
private Task _reading = Task.CompletedTask;
public EditorSession(ISequenceSource source, SequenceContent content, IReadOnlyList<EncoderCapability> codecs, TimeSpan? saveDelay = null)
{
ArgumentNullException.ThrowIfNull(source);
ArgumentNullException.ThrowIfNull(content);
Source = source;
_codecs = codecs ?? [];
_basis = content.Project;
History = new ProjectHistory(content.Project);
History.Changed += OnProjectChanged;
_saver = new ProjectSaver(SaveAsync, saveDelay ?? DefaultSaveDelay);
_saver.Failed += OnSaveFailed;
(Content, Context, Advice, Presets) = Analyse(content, _codecs);
}
/// <summary>The project changed (edit, undo, redo, Optimise, a merge).</summary>
public event Action? ProjectChanged;
/// <summary>The sequence was read again (after an analysis): frames, reports, advice and presets.</summary>
public event Action? ContentChanged;
/// <summary>
/// Saving the project failed (raised once per run of failures; the save is retried until it succeeds). A conflict
/// raises <see cref="ConflictFound"/> instead.
/// </summary>
public event Action<Exception>? SaveFailed;
/// <summary>A save met settings changed on the server too (<see cref="Conflict"/> was null): the user picks a side.</summary>
public event Action<ProjectConflictException>? ConflictFound;
public ISequenceSource Source { get; }
/// <summary>A server sequence edited with proxies: saved, analysed and rendered on the server.</summary>
public bool IsRemote => Source.IsRemote;
/// <summary>The project is shown, not changed (<see cref="ISequenceSource.IsReadOnly"/>): edits, undo and redo do nothing.</summary>
public bool IsReadOnly => Source.IsReadOnly;
public SequenceContent Content { get; private set; }
public SequenceContext Context { get; private set; }
/// <summary>The advisor's recommendations and findings for the current analyses.</summary>
public AdvisorResult Advice { get; private set; }
/// <summary>Sequence presets that fit the content, best first (BRIEF §10.3).</summary>
public IReadOnlyList<SequencePreset> Presets { get; private set; }
public ProjectHistory History { get; }
public ProjectSettings Project => History.Current;
/// <summary>A change is waiting for its save, being saved, or waiting for a retry after a failed save.</summary>
public bool HasPendingSave => _saver.HasPendingChanges;
/// <summary>Why the pending change could not be stored; null when the last save succeeded.</summary>
public Exception? LastSaveError => _saver.LastError;
/// <summary>
/// Settings this editor and someone on the server changed to different values, as the last save found them; null
/// when there are none. Saves wait (they are retried and meet it again) until <see cref="ResolveConflict"/>.
/// </summary>
public ProjectConflictException? Conflict { get; private set; }
/// <summary>Applies <paramref name="change"/> as an undoable step; false when it changes nothing.</summary>
/// <param name="mergeKey">Consecutive edits with the same key are one undo step (a slider drag).</param>
public bool Edit(Func<ProjectSettings, ProjectSettings> change, string? mergeKey = null)
{
ArgumentNullException.ThrowIfNull(change);
return !IsReadOnly && History.Apply(change(Project), mergeKey);
}
/// <summary>The drag or key press behind a run of merged edits ended (<see cref="ProjectHistory.EndRun"/>).</summary>
public void EndEditRun() => History.EndRun();
public bool Undo() => !IsReadOnly && History.Undo();
public bool Redo() => !IsReadOnly && History.Redo();
/// <summary>"Optimise section": the advisor's heavier decisions for <paramref name="section"/>, one undo step; returns what changed.</summary>
public IReadOnlyList<SettingChange> Optimise(AdvisorSection section) => Optimise([section]);
/// <summary>"Optimise all": every section, one undo step.</summary>
public IReadOnlyList<SettingChange> OptimiseAll() => Optimise(OptimisedSections);
/// <summary>"Reset": the section's Auto settings back to Auto.</summary>
public bool ResetSection(AdvisorSection section) => Edit(p => EditorSettings.ResetSection(p, section));
/// <summary>Adds frames to, or removes them from, the project's exclusions.</summary>
public bool SetExcluded(IEnumerable<int> frames, bool excluded)
{
var chosen = frames.Where(i => (uint)i < (uint)Content.Count).ToHashSet();
return Edit(p => p with
{
ExcludedFrames = excluded ? [.. p.ExcludedFrames.Union(chosen).Order()] : [.. p.ExcludedFrames.Where(i => !chosen.Contains(i))],
});
}
/// <summary>Makes <paramref name="frame"/> the hero frame (sequence thumbnail).</summary>
public bool SetHero(int frame) => (uint)frame < (uint)Content.Count && Edit(p => p with { HeroFrame = frame });
/// <summary>
/// Applies a sequence preset (BRIEF §10.3) as one undoable step: its timing, exposure, motion, aspect and export
/// preset; the user's frames (exclusions, hero), crop, keyframes, remap curve, exposure offset and output naming stay.
/// </summary>
public bool ApplyPreset(SequencePreset preset)
{
ArgumentNullException.ThrowIfNull(preset);
var s = preset.Settings;
return Edit(p => p with
{
Timing = s.Timing with { RemapCurve = p.Timing.RemapCurve, FitToSeconds = p.Timing.FitToSeconds },
Exposure = s.Exposure with { ExposureOffsetEv = p.Exposure.ExposureOffsetEv, HighlightKnee = p.Exposure.HighlightKnee },
Motion = s.Motion,
Camera = p.Camera with { Aspect = s.Camera.Aspect },
Export = p.Export with { Preset = s.Export.Preset, Overrides = new ExportOverrides() },
});
}
/// <summary>
/// A render of <paramref name="export"/> with the project as it is now (the job embeds it, so a render queued before
/// the save lands still renders what the user sees).
/// </summary>
public ArchiveJobRequest RenderRequest(ExportSettings export, bool useProxies = false) =>
ProcessingJobs.Render(Content.Sequence, export, Content.SourceWidth, Content.SourceHeight, Project with { Export = export }, useProxies);
/// <summary>
/// The jobs that render <paramref name="export"/> and its batch: one job on this PC (the sequence is prepared once),
/// one per preset on a server, where a render node uploads one file per job (BRIEF §14.7).
/// </summary>
public IReadOnlyList<ArchiveJobRequest> RenderRequests(ExportSettings export) => IsRemote
? ProcessingJobs.RenderEach(Content.Sequence, export, Content.SourceWidth, Content.SourceHeight, Project with { Export = export })
: [RenderRequest(export)];
/// <summary>
/// Makes a "Save both" copy of this PC's settings the project, as one undoable step; null when it stores the same values.
/// </summary>
/// <returns>The restore, which its toast can take back while it is the last change.</returns>
/// <exception cref="System.IO.InvalidDataException">The copy cannot be read.</exception>
public async Task<ProjectRestore?> RestoreAsync(SavedCopy copy)
{
ArgumentNullException.ThrowIfNull(copy);
var restored = await Task.Run(() => SavedCopies.Read(copy));
var before = Project;
return Edit(_ => restored) ? new ProjectRestore(this, before, Project) : null;
}
/// <summary>
/// Settles <see cref="Conflict"/> against the server's settings as the last save read them. Both choices first take
/// in what only the server changed (like any merge, without an undo step). <paramref name="keepMine"/> then saves
/// the editor's values of the settings both changed; otherwise the server's values become the project as one
/// undoable step, so Ctrl+Z brings the editor's back (and saves them).
/// </summary>
/// <returns>False when there is no conflict to settle (a later save already went through).</returns>
public bool ResolveConflict(bool keepMine)
{
if (Conflict is not { Server: var theirs }) return false;
Conflict = null;
var basis = _basis;
_basis = theirs;
History.Replace(ProjectMerge.Merge(basis, Project, theirs));
if (!keepMine) History.Apply(ProjectMerge.Merge(basis, theirs, Project));
// The change waiting for its retry goes now, on top of the server's settings.
_ = _saver.FlushAsync();
return true;
}
/// <summary>The export of the project with preset <paramref name="presetId"/> chosen (own values, no batch).</summary>
public ExportSettings ExportFor(string presetId) =>
Project.Export with { Preset = Project.Export.Preset.WithManual(presetId), Overrides = new ExportOverrides(), Batch = [] };
public ArchiveJobRequest AnalysisRequest() => ProcessingJobs.DeepAnalysis([Content.Sequence.Id], Content.Sequence.DisplayTitle);
public Task<Guid> SubmitAsync(ArchiveJobRequest request, CancellationToken cancellationToken = default) => Source.SubmitAsync(request, cancellationToken);
/// <summary>
/// Makes the project's frame positions name the sequence's frames as they are now, before the project is taken along
/// (a render embeds it): frames inserted since the last read (a sync download, an import of earlier photos, a scan)
/// are read again and the positions follow them (<see cref="ReloadAsync"/>). A server sequence whose frames changed
/// becomes outdated instead (<see cref="ISequenceSource.IsOutdated"/>: read-only, its renders refused).
/// </summary>
public async Task EnsureFramesAsync(CancellationToken cancellationToken = default)
{
while (!_reading.IsCompleted) await _reading;
var current = await Source.FramesCurrentAsync(cancellationToken);
// A read that began meanwhile (a save that met the new frames) may have taken them already: it ends first.
while (!_reading.IsCompleted) await _reading;
if (!current && !IsRemote) await ReloadAsync(cancellationToken);
}
/// <summary>
/// Reads the sequence again (an analysis finished): new reports and advice, the frames with the project's positions
/// following them (<see cref="Follow"/>), the stored project merged into the open one. Saves wait until it is taken,
/// and a read waits for the one under way, so each follows the frames the one before it took.
/// </summary>
public async Task ReloadAsync(CancellationToken cancellationToken = default)
{
await _saver.FlushAsync();
var taken = await BeginReadAsync();
try
{
var content = await Source.LoadAsync(cancellationToken);
Follow(content);
// A server's settings that conflict with the editor's waiting change are not merged over it: that change's
// retry meets them and asks (Conflict).
if (Conflict is null && (!IsRemote || ProjectMerge.Conflicts(_basis, Project, content.Project).Count == 0))
{
var merged = ProjectMerge.Merge(_basis, Project, content.Project);
_basis = content.Project;
History.Replace(merged);
}
}
finally
{
taken.SetResult();
}
ContentChanged?.Invoke();
}
/// <summary>Stores pending changes now; false when the save failed (the change stays pending and is retried).</summary>
public Task<bool> FlushAsync() => _saver.FlushAsync();
/// <summary>
/// Stops retrying a change that could not be stored while the user decides about it (<see cref="ProjectSaver.HoldAsync"/>);
/// end it with <see cref="KeepPending"/> or <see cref="DiscardPending"/>.
/// </summary>
/// <returns>True when a change is still not stored; false when a retry stored it meanwhile (nothing to decide).</returns>
public Task<bool> HoldPendingAsync() => _saver.HoldAsync();
/// <summary>The user kept the change: it is retried in the background as before.</summary>
public void KeepPending() => _saver.Release();
/// <summary>The user discarded the change: it is dropped and never written, and nothing more is saved (the editor closes).</summary>
public void DiscardPending() => _saver.Stop();
/// <summary>
/// Stores what is pending one last time, stops retrying and releases the source; callers that must not lose an edit
/// flush and ask first (<c>SequenceViewModel.ConfirmCloseAsync</c>).
/// </summary>
public async ValueTask DisposeAsync()
{
History.Changed -= OnProjectChanged;
if (!await _saver.FlushAsync()) Log.Warning("editor", $"The last change of {Content.Sequence.DisplayTitle} was not saved", _saver.LastError);
_saver.Stop();
await Source.DisposeAsync();
}
/// <summary>
/// Takes <paramref name="content"/> as the sequence. Frames inserted or removed since the last read (a sync download,
/// an import of earlier photos, a scan) moved the stored project's frame positions with their frames: the editor's
/// project, its undo and redo steps and its basis move the same way (<see cref="ProjectSettings.FollowFrames"/>), so
/// they keep naming the frames the user chose. Call while the read is under way (<see cref="BeginReadAsync"/>).
/// </summary>
private void Follow(SequenceContent content)
{
var before = Content.Frames.Select(f => f.Id).ToList();
(Content, Context, Advice, Presets) = Analyse(content, _codecs);
if (before.SequenceEqual(content.Frames.Select(f => f.Id))) return;
var after = content.Frames;
Log.Info("editor", $"The frames of {content.Sequence.DisplayTitle} changed while it was open; its frame positions follow them");
_basis = Move(_basis);
History.Remap(Move);
ProjectSettings Move(ProjectSettings project) =>
NamesFrames(project) && ProjectSettings.FollowFrames(project.ToJson(), before, after) is { } moved ? ProjectSettings.FromJson(moved) : project;
}
/// <summary>
/// Waits for the read under way (two jobs that end together read the sequence one after the other), then marks a new
/// one under way until the returned source is completed.
/// </summary>
private async Task<TaskCompletionSource> BeginReadAsync()
{
while (!_reading.IsCompleted) await _reading;
var taken = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
_reading = taken.Task;
return taken;
}
/// <summary>Exclusions, a hero, keyframes or frames waiting for their photos: positions that follow frames.</summary>
private static bool NamesFrames(ProjectSettings project) =>
project.ExcludedFrames.Count > 0 || project.HeroFrame is not null || project.Camera.Keyframes.Count > 0 || project.PendingFrames is { Count: > 0 };
private static (SequenceContent, SequenceContext, AdvisorResult, IReadOnlyList<SequencePreset>) Analyse(SequenceContent content,
IReadOnlyList<EncoderCapability> codecs)
{
var context = SequenceContext.FromFrames(content.Frames, codecs);
return (content, context, Advisor.Recommend(content.Light, content.Deep, context), SequencePresets.Generate(content.Light, content.Deep, context));
}
private IReadOnlyList<SettingChange> Optimise(IReadOnlyList<AdvisorSection> sections)
{
if (IsReadOnly) return [];
var settings = Project;
var changes = new List<SettingChange>();
foreach (var section in sections)
{
var result = Advisor.Optimise(section, settings, Advice);
settings = result.Settings;
changes.AddRange(result.Changes);
}
History.Apply(settings);
return changes;
}
private void OnSaveFailed(Exception ex, int failures)
{
// A conflict is retried without the network until the user settles it: noted once, when it is found.
if (ex is ProjectConflictException) return;
Log.Warning("editor", $"Saving the project of {Content.Sequence.DisplayTitle} failed (attempt {failures})", ex);
if (failures == 1) SaveFailed?.Invoke(ex);
}
private void OnProjectChanged()
{
_saver.Schedule(Project);
ProjectChanged?.Invoke();
}
private async Task SaveAsync(ProjectSettings project)
{
if (!_reading.IsCompleted)
{
// A read under way decides the frames the project's positions name. Once it is taken, the project as it is
// then contains this change (projects are whole snapshots), with its positions on those frames.
while (!_reading.IsCompleted) await _reading;
project = Project;
}
ProjectSettings stored;
for (var attempt = 1; ; attempt++)
{
try
{
stored = await Source.SaveProjectAsync(project, _basis, CancellationToken.None);
break;
}
catch (FramesChangedException) when (attempt < FollowAttempts)
{
// Frames were inserted under the editor and the stored positions moved with them: the frames are read
// again (after a read under way, whose move this edit's snapshot missed), the project's positions follow
// them, and the project as it is then, which contains this edit, is saved in the new order.
var taken = await BeginReadAsync();
try
{
Follow(await Source.LoadAsync(CancellationToken.None));
}
finally
{
taken.SetResult();
}
project = Project;
ContentChanged?.Invoke();
}
catch (ProjectConflictException ex)
{
var found = Conflict is null;
Conflict = ex;
if (found)
{
Log.Info("editor", $"Settings of {Content.Sequence.DisplayTitle} changed on the server too: {string.Join(", ", ex.Differences.Select(d => d.Path))}");
ConflictFound?.Invoke(ex);
}
throw;
}
}
Conflict = null;
_basis = stored;
// Someone else's change was merged in: show it without an undo step (edits made since the save are kept).
if (!ProjectMerge.SameValues(stored, project)) History.Replace(ProjectMerge.Merge(project, Project, stored));
}
}
/// <summary>
/// A "Save both" copy made the project (<see cref="EditorSession.RestoreAsync"/>). Its Undo brings back the project from
/// before as a new step, and only while the restore is still the last change: after another edit, an undo or a merged
/// save it would take that change back instead.
/// </summary>
public sealed class ProjectRestore(EditorSession session, ProjectSettings before, ProjectSettings restored)
{
public bool CanUndo => ReferenceEquals(session.Project, restored);
public bool Undo() => CanUndo && session.Edit(_ => before);
}