docs: document phase 5b, the server as a project home
Phase 5b had only module rows and the review's DECISIONS and CHANGELOG lines. The brief now describes the server home as the code does after the review fixes: the projects API, projectChanged, the capability, the settings PATCH under the lease, renders of a project version, the panel's Projects section, and the desktop's server projects (open, copy, sync, chip, renders, viewers). DECISIONS gains the phase's own rows; the 5b rows are dated 2026-10-26 like the other review-2 phases, and three 5a rows are marked partly superseded. CHANGELOG, STATUS, the request's 5b row and ARCHITECTURE follow the code (frames stamp, stored reads, the .thumb marker, followed renames, the editor's sign-in). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
ae41c95682
commit
3ade4b8d6c
6 files changed
+258
-62
No files matched your search
@@ -59,11 +59,11 @@ Dependencies point one way: `Core` ← `Core.Windows`, `Data`, `Protocol` ← `S
|
||||
| `Jobs` | `JobEngine` (one job at a time; reviews the priority queue and makes a lower running job yield, requeued with its checkpoint; no history purge, the housekeeping schedule's clean-up does it), `JobPriorityQueue` (a level per job kind, the claim order, settings round trip), `IJobHandler`, `IJobHandlerProvider`, `JobContext` (progress, checkpoints, follow-up jobs that never interrupt their parent), `JobThroughput`/`JobEta` (rate and bounded time left), `ICancelledJobHandler` (a handler's clean-up after a cancel: `JobEngine.CancelAsync` calls it for a paused or failed job no handler runs, and waits first for a paused job's run that has not ended) |
|
||||
| `Scheduling` | `Scheduler` (one per host: seeds the host's system schedules, claims due runs by compare-and-set, catch-up, clock changes, create/edit/reset/delete/run now as API v1 DTOs), `ScheduleRecurrence` (the in-house `every:`/`daily:`/`weekly:`/`monthly:` form, wall-clock times across DST), `ScheduleActions` (action names, parameters, availability, the archive jobs a run queues), `IScheduleHost` and `SystemSchedule` (what the server and the desktop supply), `ScheduleOutcome`, `ScheduleMapping` (model ↔ DTO) |
|
||||
| `Housekeeping` | `BackupJobHandler`, `CleanupJobHandler`, `ICleanupStep` with the shared steps (`CleanupSteps`: job history, audit log, trash report that never deletes); hosts add their own steps through `ArchiveServiceOptions.CleanupSteps` |
|
||||
| `Archiving` | `ArchiveService` (create/adopt/open, archive settings written to `archive.json` then the index, `ArchiveSettings.CheckTemplates` and `TemplateRuleException` holding a template given anew to the template rules; `UnderLeaseAsync`: a write under a sequence's lease with its row read under it), `ArchiveIndexer` (scan, rebuild; a sequence found in another folder takes its exports' paths along; a full scan or a rebuild takes the projects' sidecars back too), `ArchiveIngest` (uploads and imports, named through `FrameNaming`; content a conversion replaced is a duplicate of the frame holding its conversion; a restore or a replacement not settled yet refuses the batch), `ImportService`, `ArchiveVerifier`, `ArchiveImages` (thumbnail and proxy passes, several photos at once through `OrderedWork`, which hands results back in frame order), `FrameTiers` (decode tier, `PreviewOnly`/`Undecodable` flags and preview size of frames, written to sidecar and index by the light analysis, deep analysis, renders and image passes), `GprCompanions` (the JPEG of each GoPro GPR, found in the index when an import kept it in another sequence), `ArchiveMaintenance` (also a conversion job's staging and journals, by the job's state; those of a job this index does not know go together, by age), `MassRenamer` (mass rename and Reorganize: the dry run reads each sidecar for a file template; each step checked under its leases before anything of it moves (where its sequences are, what is inside and at its new folder, a sidecar of a newer format, the title it was planned from when it changes it or names the folder or files after it), then the folder, with the sequences of the plan an earlier step left as they were inside it (taken along, their title and file names kept), every index row (the frame paths and render paths of the exports inside it, a file or an image-sequence folder, its own unless the export is still at the old place and another sequence's when it moved with it, follow it in one transaction; a sidecar that cannot be read or written then still has its row follow, and fails the step), then the files under the plan's journal in `journal/` (a sequence whose photos changed since, such as one still receiving them, or whose files are found changed or in use or have their new names taken keeps its file names, the renames being pinned by digest, and the step and the plan go on); the journal keeps the tally of the whole plan, and a plan its job held (paused, cancelled or failed) is left to that job, only its half-done file renames completed at an archive open, which completes any other plan an interruption left and tells each sequence changed; the file renames of a step: sidecar, a sequence whose sidecar cannot be read staying as it is with every folder around it, index (`FrameRepository.RenameFilesAsync`) and the sequence's journal), `SequenceFolders` (`Holds`: the folder the index has for a sequence is there and its sidecar names no other sequence; every writer into a sequence's folder asks it), `SequenceTrash` (delete into the archive's hidden trash with a dry run, restore; the folder moves back when the index step fails; lists sequence and photo entries; `SequenceTrash.Empty`: the emptying's dry run, fingerprint and erase, each entry checked against its fingerprint again under its lease, `TrashKept` with its `TrashKeptReason` for each entry kept; `SequenceTrash.Replaced`: where a replaced entry's conversions are, read from the archive's sidecars (in the index's or the entry's folder, in the trash, else by one `SidecarWalk` of the archive per dry run or emptying) through their replaced tombstones, a conversion deleted only on the archive's word (a tombstone, the trash, or an `ErasureRecord` in `trash/.erased/`, written when an emptying erases a deleted sequence a replaced entry still needs), `TrashEntry.ConversionDeleted` in the dry run and its fingerprint, the erase weighed under the entry's and the sequence's leases once the sequence is settled; `BusyAsync`: what running and paused jobs hold, but the job asking, from `JobRepository.ListHoldsAsync`), `FrameTrash` (photos of a sequence into `trash/photos` with a dry run, a journal that undoes an interrupted deletion whose entry stays unlisted until its sidecar is written, tombstones (a photo never hashed is hashed as it goes; one whose original is missing goes without a file or tombstone; a frame that stays and may be a twin is hashed, its hash kept), positions parked and placed back, proxies and thumbnails moved to follow their frames; `FrameTrash.Restore`: restore re-hashes each file and says why each kept photo stayed (`KeptReason`), under a journal of its own into the sequence that another writer settles only under the entry's lease, into a new sequence through the ingest when theirs is gone, each original staged inside its own entry and the record rewritten after each photo filed; a replaced entry swaps back while its converted frames are unchanged (`SwapBackAsync`); `FLine truncated
|
||||
| `Archiving` | `ArchiveService` (create/adopt/open, archive settings written to `archive.json` then the index, `ArchiveSettings.CheckTemplates` and `TemplateRuleException` holding a template given anew to the template rules; `UnderLeaseAsync`: a write under a sequence's lease with its row read under it; `EditSettingsAsync`: settings an index edit writes, written to `project.json` under the lease first and put back when the index does not take them), `ArchiveIndexer` (scan, rebuild; a sequence found in another folder takes its exports' paths along; a full scan or a rebuild takes the projects' sidecars back too), `ArchiveIngest` (uploads and imports, named through `FrameNaming`; content a conversion replaced is a duplicate of the frame holding its conversion; a restore or a replacement not settled yet refuses the batch), `ImportService`, `ArchiveVerifier`, `ArchiveImages` (thumbnail and proxy passes, several photos at once through `OrderedWork`, which hands results back in frame order), `FrameTiers` (decode tier, `PreviewOnly`/`Undecodable` flags and preview size of frames, written to sidecar and index by the light analysis, deep analysis, renders and image passes), `GprCompanions` (the JPEG of each GoPro GPR, found in the index when an import kept it in another sequence), `ArchiveMaintenance` (also a conversion job's staging and journals, by the job's state; those of a job this index does not know go together, by age), `MassRenamer` (mass rename and Reorganize: the dry run reads each sidecar for a file template; each step checked under its leases before anything of it moves (where its sequences are, what is inside and at its new folder, a sidecar of a newer format, the title it was planned from when it changes it or names the folder or files after it), then the folder, with the sequences of the plan an earlier step left as they were inside it (taken along, their title and file names kept), every index row (the frame paths and render paths of the exports inside it, a file or an image-sequence folder, its own unless the export is still at the old place and another sequence's when it moved with it, follow it in one transaction; a sidecar that cannot be read or written then still has its row follow, and fails the step), then the files under the plan's journal in `journal/` (a sequence whose photos changed since, such as one still receiving them, or whose files are found changed or in use or have their new names taken keeps its file names, the renames being pinned by digest, and the step and the plan go on); the journal keeps the tally of the whole plan, and a plan its job held (paused, cancelled or failed) is left to that job, only its half-done file renames completed at an archive open, which completes any other plan an interruption left and tells each sequence changed; the file renames of a step: sidecar, a sequence whose sidecar cannot be read staying as it is with every folder around it, index (`FrameRepository.RenameFilesAsync`) and the sequence's journal), `SequenceFolders` (`Holds`: the folder the index has for a sequence is there and its sidecar names no other sequence; every writer into a sequence's folder asks it), `SequenceTrash` (delete into the archive's hidden trash with a dry run, restore; the folder moves back when the index step fails; lists sequence and photo entries; `SequenceTrash.Empty`: the emptying's dry run, fingerprint and erase, each entry checked against its fingerprint again under its lease, `TrashKept` with its `TrashKeptReason` for each entry kept; `SequenceTrash.Replaced`: where a replaced entry's conversions are, read from the archive's sidecars (in the index's or the entry's folder, in the trash, else by one `SidecarWalk` of the archive per dry run or emptying) through their replaced tombstones, a conversion deleted only on the archive's word (a tombstone, the trash, or an `ErasureRecord` in `trash/.erased/`, written when an emptying erases a deleted sequence a replaced entry still needs), `TrashEntry.ConversionDeleted` in the dry run and its fingerprint, the erase weighed under the entry's and the sequence's leases once the sequence is settled; `BusyAsync`: what running and paused jobs hold, but the job asking, from `JobRepository.ListHoldsAsync`), `FrameTrash` (photos of a sequence into `trash/photos` with a dry run, a journal that undoes an interrupted deletion whose entry stays unlisted until its sidecar is written, tombstones (a photo never hashed is hashed as it goes; one whose original is missing goes without a file or tombstone; a frame that stays and may be a twin is hashed, its hash kept), positions parked and placed back, proxies and thumbnails moved to follow their frames; `FrameTrash.Restore`: restore re-hashes each file and says why each kept photo stayed (`KeptReason`), under a journal of its own into the sequence that another writer settles only under the entry's lease, into a new sequence through the ingest when theirs is gone, each original staged inside its oLine truncated
|
||||
| `Processing` | `ProcessingService`, `SequenceAnalyser`, `DeepReports` (a saved deep report while it still describes the frames), `SequenceRender`, `ProjectStore`, `ProjectBundles` (a `.chronos` file for a sequence, and the sequence a file names), `RenderNodeClient`, job handlers |
|
||||
| `Projects` | `ProjectService` (`ArchiveService.Projects`: the projects of this PC's sequences as a home, under the sequence's lease and only in a folder that holds the sequence (`SequenceFolders.Holds`; otherwise `SequenceFolderMovedException`: reads answer from the index, writes are refused); reads wait 3 s for the lease, then answer from the index; a read-only archive is read without writing (an index-only Main written back once it takes writes): list, create, rename, delete (the folder into `projects/.trash` first, then the deleted record; never Main), history, head (NotFound once deleted), `StoredAsync` (a version file read back and checked), push with fast-forward / idempotent repeat / divergence / hash, portability, strict format and 64 MiB checks; each call first catches up: the sidecars into the index, Main made from the sequence's settings, settings another path wrote appended to Main as an `external` version or, with a push whose mirror was cut short, merged into one `merge` version where they win, a mirror never written over `project.json` settings it has not taken in (`MovedSharedAsync`), records behind the index healed (`HealAsync`, `UpdatedAfter`), projects the archive lost written back (`WriteBackAsync`); a push to Main mirrored into `project.json` and the settings with the settings version check), `ProjectIndexer` (the reconcile, also run by full scans and rebuilds: the projects' trash read before the live folders, so a deletion wins and the live folder's late version files move beside it; a record that cannot be read held back, never taken for a deletion; a lost record written again from the index only once its folder settled (`RecordSettle`, 2 minutes) and no trash folder holds it back (`TrashRecordGrace`, 1 day); a creation cut before its record left as it is; a version file a push left past its record adopted, a stray one moved to `versions/.stray`; `BehindAsync`, one rule for a record behind the index; `SettleMainAsync` and `SwapMainAsync`, one Main from the records, passed in one transaction), `ProjectSidecars` (record and immutable version files, the settings as a JSON string checked against their hash, `MaxVersionBytes` 64 MiB refused before writing), `ProjectMerge` (three-way merge member by member, pending frames merged photo by photo, conflicts, `Replay` of local commits on a moved head; `NewerSettingsException` rather than merge a newer format), `IProjectHome` and `ArchiveProjectHome` (the home a workspace pushes to and pulls from: `HoldsAsync` reads a version back, `FramesStampAsync` says when the frames changed, an offline archive or busy lease is `HomeUnavailableException`), `ServerProjectHome` (phase 5b: a server sequence's `/projects` over `ChronosClient`; a server out of reach, an expired sign-in, a 503 lease, offline archive or `projects_unreadable`, a 409 `folder_in_use` and a server without the projects are `HomeUnavailableException`, a 404 `sequence`/`project`/`version` and a refused name `ProjectException` (a deleted project's head is 404 `project`), a 422 `too_large` the `TooLarge` outcome, other refusals keep their `ChronosApiException`; `HoldsAsync` reads the version back, no frames stamp; its sequences name an archive id made from the server's key), `HomePhotos` (a sequence's photos as positions name them, with the encodings its Replaced tombstones join; the server's frames endpoint and render nodes build the same), what each call changed (`ProjectChangeSet` to `ArchiveServiceOptions.ProjectsChanged`, once the lease is let go: projects made, renamed, deleted or with a new head, compared before and after under the lease, and whether Main's head was written into the sequence's settings), `CatchUpAsync` (the catch-up alone, saying why it cannot run), `ProjectWire` (projects, versions, push outcomes and a home's frames to and from API v1 DTOs, for the server and a client of it) |
|
||||
| `Workspaces` | `WorkspaceStore` (a folder outside the library: `workspace.json` written atomically, one folder per project, no index; a leftover folder holding only stale lease files removed on listing), `WorkspaceProject` (`project.chronos` working state, `media/` with `media.json`, `proxies/<frame id>.jpg` (and `<frame id>-<sha16>.jpg` while a copy replaces one) and `analysis.json`, `versions/` with `.replaced` (versions set aside, pruned by age and count) and `.replaced.since`, `sync.json` for a conflict, a restore or the journal of a replay or a Save both, `exports/`, the lease `.lock.lease`; `UnreadableVersions`), `WorkspaceMedia` (`NamedAsAt`: the media learn the home's hashes and aliases), `WorkspaceSync` (checkout, open under the lease, save, commit, push, pull with replay and merge, the base in `project.chronos` as every write's commit point, `SettleAsync` finishing or undoing a cut push, replay or Save both, conflicts settled by keep mine, take server or save both only as shown, restore, status with Gone, Damaged and `MediaOutdated`, the home's frames read again only when their stamp moved), `WorkspaceCopyJobHandler` (`WorkspaceJobs.Copy` and `CopyFactsAsync`, registered by the desktop only: the archive only read, from a folder that holds the sequence; a workspace inside a library refused; the archive's current proxies copied, the others made in the workspace, each hash-verified, resumable from a checkpoint of its frames version and folder, free space checked against its estimate plus 512 MiB; the encodings conversions joined kept in `media.json`; the working state's positions moved by frame where frames stay, by photo where they came or went; a cancelled first copy's media cleared under the project's lease only when no other copy of the project waits or runs, through `ICancelledJobHandler` too; a project whose home is a server, `WorkspaceJobs.CopyFromServer`, phase 5b: downloaded through the desktop's session (`ISyncConnector`), never through this PC's archive, the frames of one frames version with the aliases of the server's conversions, each proxy (else the thumbnail standing in, `WorkspaceFrame.FileKind`) hashed as it arrives and checked on the disk, four at a time, the editor's current file never overwritten, resumable from the same checkpoint, free space checked against the server's proxy sizes) |
|
||||
| `Sync` | `SyncService` (sync table of one server: compare, link by content through the aliases, settle conflicts, enqueue transfers), `SyncRules` (status, settings merge and differences, the proxies this PC can send, aliases followed; no I/O), `SyncTombstones` (photos either side removed are not offered back; the replaced tombstones of both sides join the encodings of one photo, union-find, each compared as the smallest SHA-256 among them, a deletion covering them all; immutable once made), `SyncPositions` (the settings' frame positions translated by photo to the frames of the copy they go to), `SyncLinkStore` (`sync_links`, `sync_state`), `SyncTransfers` and `SyncJobHandler` (resumable, hash-verified uploads and downloads as jobs; downloads commit through the archive ingest, and a frame missing here whose photo the server holds in another encoding takes that file through `FrameTrash.ReplaceMissingAsync`; job log lines from the catalog), `SyncAgent` (background comparison, server events, backoff, offline proxies; a server's `projectChanged` passed on as `ProjectChanged`, and null after a lost event stream once a comparison reached the server again), `ProxyCache` and `RemoteSequence` (server sequences opened with proxies), `ISyncRemote` (the server calls; `ChronosSyncRemote` over `ChronosClient`) |
|
||||
| `Projects` | `ProjectService` (`ArchiveService.Projects`: the projects of this PC's sequences as a home, under the sequence's lease and only in a folder that holds the sequence (`SequenceFolders.Holds`; otherwise `SequenceFolderMovedException`: reads answer from the index, writes are refused); reads wait 3 s for the lease, then answer from the index; a read-only archive is read without writing (an index-only Main written back once it takes writes): list, create, rename, delete (the folder into `projects/.trash` first, then the deleted record; never Main), history, head (NotFound once deleted), `StoredAsync` (a version file read back and checked), push with fast-forward / idempotent repeat / divergence / hash, portability, strict format and 64 MiB checks; each call first catches up: the sidecars into the index, Main made from the sequence's settings, settings another path wrote appended to Main as an `external` version or, with a push whose mirror was cut short, merged into one `merge` version where they win, a mirror never written over `project.json` settings it has not taken in (`MovedSharedAsync`), records behind the index healed (`HealAsync`, `UpdatedAfter`), projects the archive lost written back (`WriteBackAsync`); a push to Main mirrored into `project.json` and the settings with the settings version check), `ProjectIndexer` (the reconcile, also run by full scans and rebuilds: the projects' trash read before the live folders, so a deletion wins and the live folder's late version files move beside it; a record that cannot be read held back, never taken for a deletion; a lost record written again from the index only once its folder settled (`RecordSettle`, 2 minutes) and no trash folder holds it back (`TrashRecordGrace`, 1 day); a creation cut before its record left as it is; a version file a push left past its record adopted, a stray one moved to `versions/.stray`; `BehindAsync`, one rule for a record behind the index; `SettleMainAsync` and `SwapMainAsync`, one Main from the records, passed in one transaction), `ProjectSidecars` (record and immutable version files, the settings as a JSON string checked against their hash, `MaxVersionBytes` 64 MiB refused before writing), `ProjectMerge` (three-way merge member by member, pending frames merged photo by photo, conflicts, `Replay` of local commits on a moved head; `NewerSettingsException` rather than merge a newer format), `IProjectHome` and `ArchiveProjectHome` (the home a workspace pushes to and pulls from: `HoldsAsync` reads a version back, `FramesStampAsync` says when the frames changed, an offline archive or busy lease is `HomeUnavailableException`), `ServerProjectHome` (phase 5b: a server sequence's `/projects` over `ChronosClient`; a server out of reach, an expired sign-in, a 503 lease, offline archive or `projects_unreadable`, a 409 `folder_in_use` and a server without the projects are `HomeUnavailableException`, a 404 `sequence`/`project`/`version` and a refused name `ProjectException` (a deleted project's head is 404 `project`), a 422 `too_large` the `TooLarge` outcome, other refusals keep their `ChronosApiException`; `HoldsAsync` reads the version back (`?stored=true`), `FramesStampAsync` from `…/frames/stamp`, version pages read on past a page the server ended early, a 413 the `TooLarge` outcome; its sequences name an archive id made from the server's key), `HomePhotos` (a sequence's photos as positions name them, with the encodings its Replaced tombstones join; the server's frames endpoint and render nodes build the same), what each call changed (`ProjectChangeSet` to `ArchiveServiceOptions.ProjectsChanged`, once the lease is let go: projects made, renamed, deleted or with a new head, compared before and after under the lease, and whether Main's head was written into the sequence's settings), `CatchUpAsync` (the catch-up alone, saying why it cannot run), `ProjectWire` (projects, versions, push outcomes and a home's frames to and from API v1 DTOs, for the server and a client of it) |
|
||||
| `Workspaces` | `WorkspaceStore` (a folder outside the library: `workspace.json` written atomically, one folder per project, no index; a leftover folder holding only stale lease files removed on listing), `WorkspaceProject` (`project.chronos` working state, `media/` with `media.json`, `proxies/<frame id>.jpg` (and `<frame id>-<sha16>.jpg` while a copy replaces one) and `analysis.json`, `versions/` with `.replaced` (versions set aside, pruned by age and count) and `.replaced.since`, `sync.json` for a conflict, a restore or the journal of a replay or a Save both, `exports/`, the lease `.lock.lease`; `UnreadableVersions`), `WorkspaceMedia` (`NamedAsAt`: the media learn the home's hashes and aliases), `WorkspaceSync` (checkout, open under the lease, save, commit, push, pull with replay and merge, the base in `project.chronos` as every write's commit point, `SettleAsync` finishing or undoing a cut push, replay or Save both, conflicts settled by keep mine, take server or save both only as shown, restore, status with Gone, Damaged and `MediaOutdated`, the home's frames read again only when their stamp moved; `FollowNameAsync`: the home's name and Main written into the copy at every pull and at a server's `renamed`), `WorkspaceCopyJobHandler` (`WorkspaceJobs.Copy` and `CopyFactsAsync`, registered by the desktop only: the archive only read, from a folder that holds the sequence; a workspace inside a library refused; the archive's current proxies copied, the others made in the workspace, each hash-verified, resumable from a checkpoint of its frames version and folder, free space checked against its estimate plus 512 MiB; the encodings conversions joined kept in `media.json`; the working state's positions moved by frame where frames stay, by photo where they came or went; a cancelled first copy's media cleared under the project's lease only when no other copy of the project waits or runs, through `ICancelledJobHandler` too; a project whose home is a server, `WorkspaceJobs.CopyFromServer`, phase 5b: downloaded through the desktop's session (`ISyncConnector`), never through this PC's archive, the frames of one frames version with the aliases of the server's conversions, each proxy (else the thumbnail standing in, `WorkspaceFrame.FileKind`) hashed as it arrives and checked on the disk, four at a time, the editor's current file never overwritten, resumable from the same checkpoint, a `<file>.thumb` marker beside a thumbnail standing in until the commit, free space checked against the server's proxy sizes) |
|
||||
| `Sync` | `SyncService` (sync table of one server: compare, link by content through the aliases, settle conflicts, enqueue transfers), `SyncRules` (status, settings merge and differences, the proxies this PC can send, aliases followed; no I/O), `SyncTombstones` (photos either side removed are not offered back; the replaced tombstones of both sides join the encodings of one photo, union-find, each compared as the smallest SHA-256 among them, a deletion covering them all; immutable once made), `SyncPositions` (the settings' frame positions translated by photo to the frames of the copy they go to), `SyncLinkStore` (`sync_links`, `sync_state`), `SyncTransfers` and `SyncJobHandler` (resumable, hash-verified uploads and downloads as jobs; downloads commit through the archive ingest, and a frame missing here whose photo the server holds in another encoding takes that file through `FrameTrash.ReplaceMissingAsync`; job log lines from the catalog), `SyncAgent` (background comparison, server events, backoff, offline proxies; a server's `projectChanged` passed on as `ProjectChanged`, and null after a lost event stream once the stream is open again and a comparison made after that reached the server: `ISyncRemote.EventsAsync(connected, ct)`), `ProxyCache` and `RemoteSequence` (server sequences opened with proxies), `ISyncRemote` (the server calls; `ChronosSyncRemote` over `ChronosClient`) |
|
||||
|
||||
### 2.3 Chronos.App areas
|
||||
|
||||
@@ -72,11 +72,11 @@ Dependencies point one way: `Core` ← `Core.Windows`, `Data`, `Protocol` ← `S
|
||||
| `Shell` | `MainWindow` (rail and its shortcuts, taskbar progress), `ShellViewModel` (rail, sections, first run), `OsNotifications` (toasts as Windows notifications while the window is minimised or in the background), dialogs, `ErrorText` (the sentence of an error toast), `ScreenCapture` (`--capture` scenes), `SectionTemplates.xaml` (view model → view) |
|
||||
| `Sections` | One `XxxView.xaml` + `XxxViewModel` per screen: Welcome, Library, Sequence (the Edit section: the editor, `SequencePickerView` choosing in place a project of the workspace or a sequence of the library, the in-window dialogs of the workspace, and the opening of this PC's sequences as workspace projects: the project opened last, else "Open in workspace", the checkout and the copy job followed until it opens), Import, Archive, Jobs (two tabs, Queue and Scheduled: `SchedulesView` shows `Jobs/SchedulesViewModel`), Server, Settings (its last page is About) |
|
||||
| `Library` | Filter, facets, pager, timeline, saved views, quick and mass actions (`MassActions`: Reorganize and Convert for the sequences of one archive), remote cards and thumbnails, thumbnail cache, list export |
|
||||
| `Editor` | `EditorSession` (project, undo/redo, saving, merges through `Data/Projects/ProjectMerge`), `ISequenceSource` (`LocalSequenceSource`, `RemoteSequenceSource`, `WorkspaceSequenceSource`: a workspace project over its media, the working state saved in `project.chronos` under the project's lease and merged photo by photo in the portable form (`Merge`, a setting both sides changed asked through `ProjectConflictException`), `ReadOnlyChanged` for a project of a newer Chronos, an unstored edit kept aside in `versions/.replaced` (`SetAsideAsync`), renders at the home with the portable settings through `IProjectRenders`, naming a version only while none waits to be sent; a server home's analyses and renders are the server's jobs, a render naming the version the server holds when the project is in step with it), `ServerJobs` (a server sequence's analyses and renders followed through its events, shared by `RemoteSequenceSource` and a server home's `WorkspaceSequenceSource`), the steps of the Edit path (`EditPath`: their order, each step's state, the step of each finding, the memory of the step shown; tabs Analysis, Frames, Exposure, Motion, Camera, Time, Stack, Export), `PreviewRenderer`, `ExportPlanner`, `ExportSync`, `SavedCopies`, `SequenceJobs`, `ProjectFiles` (save and open `.chronos` project files: format 2 opens its workspace project, format 1 gives its settings to Main) |
|
||||
| `Editor` | `EditorSession` (project, undo/redo, saving, merges through `Data/Projects/ProjectMerge`), `ISequenceSource` (`LocalSequenceSource`, `RemoteSequenceSource`, `WorkspaceSequenceSource`: a workspace project over its media, the working state saved in `project.chronos` under the project's lease and merged photo by photo in the portable form (`Merge`, a setting both sides changed asked through `ProjectConflictException`), `ReadOnlyChanged` for a project of a newer Chronos, an unstored edit kept aside in `versions/.replaced` (`SetAsideAsync`), renders at the home with the portable settings through `IProjectRenders`, naming a version only while none waits to be sent; a server home's analyses and renders are the server's jobs over `WorkspaceServerHome(connect, session)`, which connects again when the sign-in changes, a render naming the version the server holds when the project is in step with it), `ServerJobs` (a server sequence's analyses and renders followed through its events, shared by `RemoteSequenceSource` and a server home's `WorkspaceSequenceSource`), the steps of the Edit path (`EditPath`: their order, each step's state, the step of each finding, the memory of the step shown; tabs Analysis, Frames, Exposure, Motion, Camera, Time, Stack, Export), `PreviewRenderer`, `ExportPlanner`, `ExportSync`, `SavedCopies`, `SequenceJobs`, `ProjectFiles` (save and open `.chronos` project files: format 2 opens its workspace project, format 1 gives its settings to Main) |
|
||||
| `Workspace` | Owner review 2, R8: `WorkspaceHost` (the desktop's `WorkspaceStore` and `WorkspaceSync` over Settings › Workspace's folder, this PC's archive or, through `SyncHost.ProjectHome`, the signed-in server as the home (a server it is not signed in to reads as offline; `HomeChanged` from the server's `projectChanged`, texts worded for it by `WorkspaceText.ForHome`); checkout and copy with its size and free space, status, Save version with the sync after it, sync, resolve, restore, history, open, new, rename, delete, the plan and removal of a local copy whose files but the media go to `<workspace>/.trash` (put back whole when a move fails), pruning past Kept versions after `HoldsAsync`, copies a newer Chronos wrote or that cannot be read listed as such and never changed, a folder inside a library refused, `PlanFolderAsync` and `UseFolderAsync`), `WorkspaceFolderChange` (Settings › Workspace › Change… and the refused folder's Choose folder), `ProjectMenuViewModel` (the title's ▾: state chip read again after edits, the menu, Update media; `IWorkspaceUi` is what it asks of the section, `ShowDialogWhenFree` holding a background conflict until the open dialog closes), `WorkspaceDialogs` (Open in workspace with unreadable projects listed disabled, project name, Save version, History, conflict, a format conflict offering only Save both, Remove local copy with its typed confirmations; `WorkspaceDialogs.xaml`), `WorkspaceProjectItem` (a picker row), `WorkspaceText` (states, versions, authors, failures) |
|
||||
| `Import` | `CardPool` (inserted cards, remembered cards, folders), camera profiles, plans and choices, destinations (archive, folder, server through `ServerImportSink`), card actions (verified delete, format, eject) |
|
||||
| `Archive` | `CurrentArchive`, `ArchiveTree`, figures for the charts, maintenance reports, Reorganize (`ReorganizeDialogViewModel`: folder, file and title templates each with its switch, the dry run, Apply queues the `move` job of that plan; `ReorganizePlans`: each template's check, the plan as rows and a summary; `ReorganizeOffer`: per archive, the templates Settings › Archive's toast offers, joined while that archive's toast is up), Convert (`ConvertDialogViewModel`: format, JPEG quality and a mode chosen at every run, the dry run made once per format and quality, Apply behind the mode's confirmation queues the `convert` job of that plan through `MassConverter.QueueAsync`; `ConvertPlans`: the plan as rows in the mode's words, a summary, the space line, the Replace confirmation that types the number of photos and the New sequence one that counts the photos not copied; `ConvertUndo`: the Undo the Jobs screen's toast offers when Replace conversions end, which restores the `Replaced` trash entries their jobs made, by the job's id), retag, delete and trash dialogs (`SequenceDeletion`, `DeletePlans`, `TrashEmptyPlans`: Empty… behind a dry run and a typed confirmation, every entry whose conversion was deleted named first), `ArchiveFailures` |
|
||||
| `Server` | `ServerSession`, `ConnectFlow` (trust on first use), `SyncHost` (sync engine, agent, metered hold, editor connections, Export Sync), sync table, `RemoteSequenceApi` |
|
||||
| `Server` | `ServerSession`, `ConnectFlow` (trust on first use), `SyncHost` (sync engine, agent, metered hold, editor connections, Export Sync; `HasProjects`, `ProjectHome` and `ProjectChanged`, also told with null at each session start and stop: the server as a project home), sync table, `RemoteSequenceApi` |
|
||||
| `Jobs`, `Settings`, `About` | Job list and buffering, `JobNotices` (which job endings raise a toast, conversions among them; `JobEndings` lets a batch speak once); the schedules of Jobs › Scheduled (`DesktopScheduleHost`: the desktop's `IScheduleHost` and its system schedules `archive-scan`, `index-backup`, `housekeeping`; `CacheTrimStep`, the host's clean-up step; `SchedulesViewModel`, `ScheduleRowViewModel`, `ScheduleEditorViewModel` and `ScheduleDialogs.xaml`, the in-window editor; `ScheduleText`); settings rows (`LogSettingsRows`: Advanced's log rows; `WorkspaceSettingsRows`: Settings › Workspace), encoder and format inventories, `ProcessingTuning` (Settings › Rendering and Analysis applied to each job: parallelism, memory budget, quality), `InterfacePriority`, language catalog, naming preview; `AboutViewModel` (owned by the shell, not a section: Settings › About, the update notice of Settings › Updates and the update check on start), update check and download |
|
||||
| `Infrastructure` | `AppServices` (composition root; `SequenceReorganized`, raised after each Reorganize step and each sequence a conversion replaced or made, reloads an editor open on that sequence; the archive engine's free space from `VolumeInfo.FreeBytesAt`), `AppSettings`, `AppLogging` (Settings › Advanced › Logs applied to the log files from their first line, a launch that only hands over included, and at every save), `AppEnvironment` (installed or portable), `AppClock` (today's date, frozen by `--capture`), `StartWithWindows` (this copy's sign-in entry), `UiLanguage`, `LiveRegion`, `RenderNodeHost`, `DiagnosticsBundle`, `ShellActions` (BRIEF §8.6), `SingleInstance` (one Chronos per data folder; a later launch hands its file over a named pipe, or waits for a closing one to exit and starts in its place), device monitor |
|
||||
| `DesignTime` | `SampleData`: the archive, jobs and server the screenshots and smoke tests run on, dated from the fixed `SampleData.Now` |
|
||||
@@ -89,7 +89,7 @@ Dependencies point one way: `Core` ← `Core.Windows`, `Data`, `Protocol` ← `S
|
||||
| `Ui/Controls` | `ChronosWindow` (chrome, language direction), `NavRail`, `JobBar`, `ToastHost` (`Toast.Closed` once a toast leaves the screen), `Field` (placeholder, icon, error), `Chip`, `AutoSlider`, `StatusGlyph`, `EmptyState`, `Icon`, `Bidi` (right-to-left rules), `Motion` (animations off for screenshots) |
|
||||
| `Ui/Interop` | DWM calls of the window chrome; `TrayIcon` (`Shell_NotifyIconW`: the Uploader's tray, the client's Windows notifications) |
|
||||
| `Ui/Visuals` | `DrawingElement` (hover readout, item keyboard and activation) and its charts (`BarChart`, `SeriesChart`, `StackedBar`, `HeatmapStrip`, `TimelineBands`), `Filmstrip`, `PreviewViewport`, `CurveEditor`, `SequenceCard`, `VirtualizingWrapPanel`, `SegmentedControl`, `SplitButton` |
|
||||
| `Server/Api`, `Server/Events` | Endpoint groups (`XxxEndpoints.Map`; `ScheduleEndpoints`: `/api/v1/schedules`; `LibraryEndpoints`: the Library filters' facets, sequence thumbnail, photo delete, bulk delete/retag/jobs; `TrashEndpoints`: list, restore, empty (`conversionDeleted` in its dry run); `ProjectEndpoints`: `/api/v1/sequences/{sid}/projects` through the archive's `ProjectService` (list with Main first, create, rename, delete, head, versions a page at a time, one version, push with its outcome as `ProjectPushResultDto`, the frames and photo aliases a workspace places positions on); `ArchiveEndpoints`: settings, statistics, scan jobs, Reorganize's dry run and `move` job, Convert's dry run and `convert` job, both through `PlanCache`: a dry run's plan, made apart from its request, a few at once across both kinds, kept a few minutes while what it reads from the index stays (typed keys `PlanKey<TPlan>`: `ReorganizePlanKey`, `ConvertPlanKey` from `GetConvertStampAsync`, the selection and the target with the quality that counts, not the mode), for the same dry run and its confirmation; a conversion's confirmation takes only a kept plan (`Kept`), its busy sequences and free space taken again), API errors, the WebSocket `EventHub` |
|
||||
| `Server/Api`, `Server/Events` | Endpoint groups (`XxxEndpoints.Map`; `ScheduleEndpoints`: `/api/v1/schedules`; `LibraryEndpoints`: the Library filters' facets, sequence thumbnail, photo delete, bulk delete/retag/jobs; `TrashEndpoints`: list, restore, empty (`conversionDeleted` in its dry run); `ProjectEndpoints`: `/api/v1/sequences/{sid}/projects` through the archive's `ProjectService` (list with Main first, create, rename, delete, head, versions a page at a time, one version, push with its outcome as `ProjectPushResultDto` under a 65 MiB body limit, the frames and photo aliases a workspace places positions on and their stamp; pages capped at 4 Mi settings characters, `summary` and `stored` reads, 409 `sequence_empty` for a sequence without photos, deletion by the owner, an admin or the maker's own account); `SequenceEndpoints`' settings `PATCH` through `ArchiveService.EditSettingsAsync`; `ArchiveEndpoints`: settings, statistics, scan jobs, Reorganize's dry run and `move` job, Convert's dry run and `convert` job, both through `PlanCache`: a dry run's plan, made apart from its request, a few at once across both kinds, kept a few minutes while what it reads from the index stays (typed keys `PlanKey<TPlan>`: `ReorganizePlanKey`, `ConvertPlanKey` from `GetConvertStampAsync`, the selection and the target with the quality that counts, not the mode), for the same dry run and its confirmation; a conversion's confirmation takes only a kept plan (`Kept`), its busy sequences and free space taken again), API errors, the WebSocket `EventHub` |
|
||||
| `Server/Security` | Accounts, password hashing, tokens, session cookies, login guard, access rules, audit log |
|
||||
| `Server/Storage`, `Server/Jobs` | Archive and processing modules (the archive module's `SequenceChanged` publishes `sequenceChanged` `reorganized`, `converted` and `created`; its `FreeSpace` is `VolumeSpace.WritableFree`, the tighter of the space path's volume and the folder's own), uploads (`UploadMaintenance`: recovery at start, and the sweep that is the `uploads` clean-up step; `UploadService.ReceiveAgainAsync`: a verified upload whose filing was refused for now goes back to receiving, 503), render store (files a render under the sequence's lease, where the index has the folder then, with the project and version a node's job rendered; `FolderMovedException`, 503 `folder_moved`, when the sequence is not in it); `ProjectCatchUp` (Main takes settings written outside the projects soon after a `PATCH`, an analysis or a conversion, for sequences with a Main: `projectChanged` without waiting for the next project call); the archive module's `ProjectsChanged`, published as `projectChanged` (and `sequenceChanged` `settings` when Main was mirrored); `JobEngineHost`, `SchedulerHost` (the `Scheduler` on the engine, started after it; archive.json read every 10 minutes whatever the scan schedule does; every schedule change and run published as a `scheduleChanged` event) and `ServerScheduleHost` (time zone, archive refreshed from archive.json, system schedules), render node service (a job of a project version claimed with that version's settings placed on the frames it lists), monitor and availability |
|
||||
| `Server/Hosting`, `Server/Admin/web` | `ServerHost`, `ServerLogging` (console and file levels the logging filters read at every line, the file sink's limits, the engine's level; applied again when Settings › Logs is saved), certificates, discovery beacon, embedded static files (`EmbeddedStaticFiles`: `no-cache` and a content ETag, so an upgrade never mixes old and new modules), Windows service (start and stop failures in the Application event log); the admin panel (ES modules, one per page; `schedules.js` is the Jobs page's Scheduled tab; the Library's views in `pages/library/`: `sequence.js` a sequence and its photo viewer, `projects.js` its Projects section (Main marked, head and last change, versions on demand, Rename and Delete of the others, live on `projectChanged`; nothing that edits settings), `trash.js` the archive's trash, `shared.js` cards, selection, grid keyboard and the retry of thumbnails a finished job may have built; `upload.js` the upload dialog the Library opens on demand, hashing in the module worker `hash-worker.js` with the in-house incremental SHA-256 of `sha256.js`, self-tested before its first use, and sending the capture time `capture-time.js` reads: the Exif DateTimeOriginal of a JPEG or TIFF-based file, else the file's time; `reorganize.js` the Reorganize dialog of the Library's selection and of the Archive page's save toast: template switches and fields, a live dry run of `POST /archive/reorganize` one request at a time, Apply that sends the shown plan's fingerprint back; `convert.js` the Convert dialog of the Library's selection (`planTarget` in `library.js`, shared with Reorganize: the ids, at most 1,000, or `all`): format, JPEG quality and a mode chosen at every run (Replace or New sequence, never preselected), a debounced dry run of `POST /archive/convert` one request at a time, asked in Replace's words until a mode is chosen and again while the server is still making it (a proxy's cut-off, `plan_dropped`), per sequence photos converted, left as they are or not copied and why, blocked, size before and after, the space line; Apply that confirms Replace by a typed word and New sequence with the photos not copied, asks the dry run again and sends the shown plan's fingerprint back, never twice after no answer; `pages/library/trash.js` gives replaced entries their own Restore and lists those whose conversion was deleted first; `audit.js` reads `archive_converted` as a sentence) |
|
||||
|
||||
+152
-7
@@ -294,6 +294,15 @@ working state, its versions and the sequence's proxies (originals from phase 5c)
|
||||
renders run where the originals are. A local-only library works the same way, its archive
|
||||
being the home.
|
||||
|
||||
Server home (amended 2026-10-26, R8). A Chronos Server whose `server/info` lists the
|
||||
`projects` capability is the home of its sequences, with the same rules as this PC's
|
||||
archive (§7, §14.3, §14.5). A server sequence opens in the workspace like a sequence of this
|
||||
PC: its proxies are downloaded into the workspace, its versions are pushed to and pulled from
|
||||
the server, and its renders and analyses run on the server. The server is reached only
|
||||
through this PC's sign-in on the Server screen: a project of a server this PC is not signed
|
||||
in to still opens from the workspace and reads Offline. An older server's sequences open
|
||||
with proxies as before (§14.5).
|
||||
|
||||
---
|
||||
|
||||
## 5. Domain model
|
||||
@@ -669,6 +678,13 @@ under the sequence's lease (a read waits at most 3 s for it, then answers from t
|
||||
project no index knows, is a creation cut short: it holds nothing back and is left as it
|
||||
is. One Main per sequence is decided from the records (the oldest that says Main); any
|
||||
other becomes an ordinary project with every version kept.
|
||||
- A sequence with no folder yet (a server's sequence made before its first photo) keeps no
|
||||
projects: it lists none, and every change is refused before anything is written (amended
|
||||
2026-10-26, R8).
|
||||
- On a server, a `PATCH` of a sequence's settings writes them to its `project.json` under
|
||||
the sequence's lease first, then to the index, and puts the file back when the index does
|
||||
not take them, so Main never takes an older file for the sequence's settings (amended
|
||||
2026-10-26, R8).
|
||||
|
||||
Rules: originals are immutable (never rewritten; edits are settings; a conversion takes an
|
||||
original out of its sequence only into the trash, amended 2026-10-26, R7); every write of a
|
||||
@@ -1108,7 +1124,8 @@ player smoke test on Windows CI.
|
||||
- Open (a card, the Archive manager's Open, Jobs' Open; amended 2026-10-26, R8) opens a
|
||||
sequence of this PC in Edit as a project of the workspace (§12.3): the project of that
|
||||
sequence opened last on this PC, else *Open in workspace* asks which. A server-only
|
||||
sequence still opens with proxies (§14.5) until the server home (phase 5b).
|
||||
sequence opens the same way, as a project whose home is the server, when the server keeps
|
||||
projects and the account may edit; otherwise it opens with proxies (§14.5).
|
||||
|
||||
### 12.3 Edit (amended 2026-10-16, R7; formerly "Sequence editor"; amended 2026-10-26, R8)
|
||||
|
||||
@@ -1172,7 +1189,8 @@ player smoke test on Windows CI.
|
||||
|
||||
Workspace (amended 2026-10-26, R8; §4.4, §7). Edit opens a sequence of this PC's archive only
|
||||
as a project of the workspace, and never writes into the library; a capture (sample data)
|
||||
keeps editing the library, and a server sequence keeps opening with proxies until phase 5b.
|
||||
keeps editing the library. A server sequence opens as a project of the workspace too when its
|
||||
server keeps projects (server home, below); otherwise it opens with proxies as before.
|
||||
- Which project: the one of that sequence opened last on this PC. Otherwise *Open in
|
||||
workspace* asks: **Project** (an existing one, Main first, made from the sequence's
|
||||
settings as they are; or New, with a name of 1–60 characters unique in the sequence) and
|
||||
@@ -1245,9 +1263,43 @@ keeps editing the library, and a server sequence keeps opening with proxies unti
|
||||
- `.chronos` files: format 2 opens its workspace project (a copy of one gives it its
|
||||
settings as one undo step; a project the library lacks falls back to Main); format 1
|
||||
gives its settings to the sequence's Main. *Save project file* still writes format 1.
|
||||
- Server home (amended 2026-10-26, R8; §4.4, §14.3, §14.5). A sequence of a server that
|
||||
keeps projects (the `projects` capability) opens as a project whose home is that server,
|
||||
through this PC's sign-in:
|
||||
- *Open in workspace* lists the server's projects (Main first, or New) and the media
|
||||
(*Proxies*); it shows no copy size, and the copy checks the drive's free space as it
|
||||
goes. A project of the sequence already in the workspace opens from there, the server
|
||||
reachable or not. A project asked for (a `.chronos` file) that the server does not have
|
||||
opens the sequence's Main instead.
|
||||
- An account without Edit gets the sequence with proxies, read-only, and nothing is
|
||||
checked out. A copy the workspace already holds still opens; its pushes are refused
|
||||
(*Your account cannot change the projects of this server.*).
|
||||
- The *Workspace copy* job downloads through the signed-in session, never through this
|
||||
PC's archive: the frames of one frames version with the aliases of the server's
|
||||
conversions, each frame's proxy, or its thumbnail while the server has none (a later
|
||||
copy, *Update media*, takes the proxy once the server has it), and the server's deep
|
||||
report. Each file is hashed as it arrives and checked on disk, four at a time,
|
||||
resumable. Downloads are not held on a metered connection (only uploads are).
|
||||
- Texts name the server (*Server newer*, *Not on server*, *Take server's*). The chip and
|
||||
the picker's rows of the server's projects follow its `projectChanged` at once; after a
|
||||
lost event stream, and when the sign-in starts or ends, every project of that server
|
||||
reads its state again. A project the server deleted reads *Not on server*; its copy and
|
||||
unsent versions are kept. A rename on the server reaches the copy at once, and at every
|
||||
pull.
|
||||
- Renders run on the server and render what it holds. Changes not saved as a version, or
|
||||
versions not sent, are offered first: *Send and render* saves and sends them, *Keep*
|
||||
renders nothing. The job names the version the server holds, without settings, and the
|
||||
server renders it with the job's export. Offline, *Not on server*, Damaged or media
|
||||
removed: nothing is rendered and a toast says why. Analyses run on the server; with
|
||||
Sync automatically on, Main takes their Auto values when the server tells its next
|
||||
change (within 2 minutes).
|
||||
- The editor connects with the sign-in in use at each render or analysis, so a project
|
||||
opened signed out renders once signed in. Projects name the server by the address they
|
||||
were made with: signed in to the same server through another address, they read
|
||||
Offline.
|
||||
- Not yet (phase 5c): originals in the workspace and renders from them, moving the
|
||||
workspace folder with its projects, emptying `<workspace>/.trash`, automatic clean-up and
|
||||
the size limit. The server home is phase 5b.
|
||||
the size limit.
|
||||
|
||||
### 12.4 Import (cards)
|
||||
|
||||
@@ -1510,6 +1562,12 @@ trusted yet, `server/info` is read once without checking it and without credenti
|
||||
a Chronos answer leads to the fingerprint question, so another service's certificate is never
|
||||
offered for trust (amended 2026-11-04, owner review 3).
|
||||
|
||||
Row actions of a server sequence (amended 2026-10-26, R8). On a server that keeps projects
|
||||
(§4.4), an account with Edit gets *Open in workspace* (§12.3) in place of *Open with
|
||||
proxies*; *Download originals* stays for an account that may download them. An account
|
||||
without Edit gets *Open with proxies*. On an older server, *Open in workspace* is shown
|
||||
disabled after the other actions, and its tooltip says the server needs an update.
|
||||
|
||||
### 12.8 Settings
|
||||
|
||||
Sections (list on the left, controls on the right, no descriptions — tooltips only):
|
||||
@@ -1657,6 +1715,11 @@ POST /api/v1/sequences/{id}/frames/delete {frameIds, expectedFramesVersion, d
|
||||
POST /api/v1/sequences/bulk/delete {ids, dryRun} · /bulk/retag {ids, add, remove} · /bulk/jobs {ids, kind} → an item per id
|
||||
GET /api/v1/frames/{id}/original · /proxy · /thumb (streamed, Range supported)
|
||||
|
||||
GET /api/v1/sequences/{sid}/projects live projects, Main first · POST {name, fromVersionId?} → 201 project
|
||||
GET/PATCH {name}/DELETE /sequences/{sid}/projects/{pid} · GET …/{pid}/head · GET …/{pid}/versions?before|after&limit&summary · GET …/{pid}/versions/{vid}[?stored=true]
|
||||
POST /api/v1/sequences/{sid}/projects/{pid}/versions push → 201 stored | 200 already_stored | 409 project_diverged | 422 hash_mismatch, newer_format, invalid_version, too_large
|
||||
GET /api/v1/sequences/{sid}/projects/frames every frame and the photo aliases of replaced tombstones, of one frames version · GET …/frames/stamp
|
||||
|
||||
POST /api/v1/uploads {sequenceId|null, fileName, size, sha256, capturedAt?, sessionKey?, restore?} → {uploadId, chunkSize, received[]} | 200 {alreadyExists, frameId?}
|
||||
PUT /api/v1/uploads/{id}/chunks/{n} body bytes (idempotent) → {received}
|
||||
POST /api/v1/uploads/{id}/complete[?restore=true] → frame id (server verifies sha256, commits into layout, updates manifest)
|
||||
@@ -1666,7 +1729,7 @@ DELETE /api/v1/uploads/{id}
|
||||
GET /api/v1/jobs?state · POST /jobs {kind, target, params} · GET /jobs/{id} · POST /jobs/{id}/cancel · /retry
|
||||
GET /api/v1/schedules schedules (system ones first), actions with availability, time zone, clean-up steps (admin)
|
||||
POST /api/v1/schedules · GET/PUT/PATCH/DELETE /schedules/{id} · POST /schedules/{id}/run · /reset · GET /schedules/{id}/runs?cursor&limit
|
||||
WS /api/v1/events {type: jobProgress|jobState|sequenceChanged|cardEvent|nodeState|scheduleChanged, …}
|
||||
WS /api/v1/events {type: jobProgress|jobState|sequenceChanged|cardEvent|nodeState|scheduleChanged|projectChanged, …}
|
||||
|
||||
POST /api/v1/nodes/register · POST /nodes/{id}/heartbeat · POST /nodes/{id}/claim → job · POST /nodes/{id}/jobs/{jobId}/result (chunked upload of output)
|
||||
|
||||
@@ -1844,6 +1907,52 @@ and every move of a next run; older clients ignore it. `GET/PUT /server/settings
|
||||
the log group `logs` (R11; a `PUT` without it keeps the log settings) and `lockedBy`, the
|
||||
environment variable that fixes each locked setting (ignored when saving).
|
||||
|
||||
Projects (amended 2026-10-26, R8; §7, §12.3, §14.5). The server keeps its sequences'
|
||||
projects as this PC's archive does (§7), and `server/info` lists the capability
|
||||
`projects`. A server without it answers 404 `not_found` with no details.
|
||||
- Reading needs Read; making, renaming and pushing need Edit. Deleting needs Delete and an
|
||||
admin, the sequence's owner or the project's maker (the same username, on an account made
|
||||
no later than the project); otherwise 403 `forbidden`. Main is never deleted (409
|
||||
`main_cannot_be_deleted`); the API can rename it.
|
||||
- The list makes Main from the sequence's settings the first time it is read (503 when that
|
||||
cannot be done now). A sequence with no photo yet lists no projects, and every change
|
||||
answers 409 `sequence_empty`.
|
||||
- Errors: 404 `not_found` with details `sequence`, `project` or `version`; 400
|
||||
`invalid_name` (1–60 characters after trimming, no control characters); 409 `name_taken`
|
||||
(any case, among live projects); 503 `archive_offline`, `sequence_busy`, `folder_moved` or
|
||||
`projects_unreadable` for writes (reads wait at most 3 s for the lease, then answer from
|
||||
the index); 409 `folder_in_use` when a project's file cannot be written.
|
||||
- A deleted project answers 404 `project` to its GET, head, rename, push and delete; its
|
||||
versions can still be read.
|
||||
- Version pages: newest first below `before` (default 50), or oldest first above `after`
|
||||
(default 100); `limit` 1–200; `more` when more follow. A page also ends before its
|
||||
settings pass 4 Mi characters (one version always goes). `summary=true` leaves the
|
||||
settings out. `?stored=true` answers a version only when its file on the server reads back
|
||||
with its content hash (404 `version` otherwise, `project` for a deleted project).
|
||||
- A push body may be up to 65 MiB (the 64 MiB version limit plus 1 MiB; 413 `too_large`
|
||||
above). The server numbers the version head + 1 and records the pushing account as its
|
||||
author, and the version's client name, else the token's. Answers are `{outcome, version,
|
||||
head, code, message}`: 201 `stored`; 200 `already_stored` (the same id and hash again);
|
||||
409 `diverged` / `project_diverged`, with the head; 422 `hash_mismatch`, `newer_format`,
|
||||
`invalid` / `invalid_version` (not portable, or another project's id) and `too_large` (a
|
||||
version file over 64 MiB). A version of Main is mirrored into the sequence's settings.
|
||||
- `…/projects/frames` answers every frame in index order and the replaced tombstones as
|
||||
photo aliases, of one frames version; `…/frames/stamp` answers a short stamp of them
|
||||
(frames version, hashed photos and their checksum, removals), so a workspace reads the
|
||||
frames again only when it moved.
|
||||
- Creations, renames (when the name changed) and deletions are audited `project_created`,
|
||||
`project_renamed`, `project_deleted`; every push is logged.
|
||||
- `projectChanged {sequenceId, projectId, change: created|renamed|deleted|pushed,
|
||||
headNumber, headVersionId}` goes to every signed-in subscriber after each change: the
|
||||
API's own, Main made at the first read, Main's external or merge versions, and projects
|
||||
and versions another program wrote, found in the sidecars by a project call, a full scan
|
||||
or a read-only catch-up. Main passing to another project reads as `renamed`. Main's head
|
||||
written into the settings also sends `sequenceChanged` `settings`. Older clients ignore it.
|
||||
- A `PATCH /sequences/{id}` that carries settings writes them under the sequence's lease
|
||||
(§7), waiting 20 s for it, and can answer 503 `archive_offline`, `sequence_busy` or
|
||||
`folder_moved`, or 409 `folder_in_use`, with nothing changed. A `PATCH` of title, tags,
|
||||
rating or notes alone writes the index only.
|
||||
|
||||
### 14.4 Upload and ingest
|
||||
|
||||
Client computes SHA-256 while reading; `POST /uploads` short-circuits if the hash exists;
|
||||
@@ -1981,9 +2090,24 @@ only settings both sides changed are a conflict. Versions are compared and place
|
||||
photo or a conversion that replaced one never move a position. Only Main's head is
|
||||
mirrored into the sequence's settings, so only Main crosses to a linked server copy,
|
||||
through the settings sync above; other projects never leave their home. A home that is
|
||||
read-only or out of reach leaves the versions waiting in the workspace. Phase 5a's home is
|
||||
this PC's archive; the server home (API under `/sequences/{id}/projects`, the
|
||||
`projectChanged` event) is phase 5b.
|
||||
read-only or out of reach leaves the versions waiting in the workspace. The home is this
|
||||
PC's archive or a server (§14.3).
|
||||
|
||||
Server home (amended 2026-10-26, R8; §12.3, §14.3). A server's projects work as on a PC's
|
||||
archive:
|
||||
- Settings a `PATCH`, an analysis's Auto values or a conversion's Replace write become
|
||||
Main's next (external) version soon after, in the background, told as `projectChanged`
|
||||
`pushed`. This holds only for sequences that already have a Main; Main is still made
|
||||
from the settings at the first read. A busy sequence is tried again after 5 s, 30 s and
|
||||
2 minutes, then left to the next project call.
|
||||
- Other projects never leave the server; a desktop's linked copy still syncs Main through
|
||||
the settings.
|
||||
- The desktop takes `projectChanged` from its sync connection. After a lost event stream it
|
||||
reads the state of that server's projects again only once the stream is open again and a
|
||||
comparison made after that reached the server.
|
||||
- A workspace reads the server's versions page by page, reading on past a page the server
|
||||
ended early, and prunes a kept version only after reading it back from the server's file
|
||||
(`?stored=true`).
|
||||
|
||||
### 14.6 Job engine
|
||||
|
||||
@@ -2088,6 +2212,15 @@ per job settings), renders with its GPU, uploads the result as a render of the s
|
||||
Node state shown in admin › Jobs; the server falls back to managed formats when no node is
|
||||
available and says so in the job log.
|
||||
|
||||
Project versions (amended 2026-10-26, R8). A render job may name `projectId` and
|
||||
`projectVersionId`. `POST /jobs` checks them against the target sequence (404 `not_found`
|
||||
`project` or `version`): a version must belong to a project of the sequence and names its
|
||||
project; a project alone, without settings of its own, is pinned to its head when the job is
|
||||
queued; a deleted project's versions still render. The server's own render and a node's claim
|
||||
get that version's settings (or the job's own portable settings) placed on the sequence's
|
||||
frames; a node gets them placed on the frames its claim lists, read as one frames version.
|
||||
The render records the project and the version. Jobs without them render as before.
|
||||
|
||||
### 14.8 Admin web panel (`/admin`, vanilla HTML/CSS/JS, ES modules, no build step, same API)
|
||||
|
||||
```
|
||||
@@ -2178,6 +2311,17 @@ operations; it queues no deep analysis (the API's `bulk/jobs` takes `deep`).
|
||||
confirmation that asks for their number to be typed when more than 20 go, the sequence's
|
||||
frames version sent so a changed sequence refuses); *Delete…* of the sequence; its
|
||||
renders, to download; *Add photos* (the upload dialog, R3).
|
||||
- *Projects* on a sequence's page (amended 2026-10-26, R8; §14.3): the sequence's projects,
|
||||
Main first, named in the panel's language while it keeps the name Main and marked *Main*
|
||||
once renamed; each with its newest version number and who changed it last and when. A
|
||||
click on a project opens its versions (number, kind: Saved, Merged, Restored, Imported,
|
||||
Outside change; author or client, note, time; the head marked *Newest*), 20 at a time
|
||||
with *Load more*, read without their settings. *Rename…* and *Delete…* only for projects
|
||||
other than Main; Delete asks for a confirmation naming the project, which goes with its
|
||||
versions into the sequence's project trash. The section makes no project, pushes,
|
||||
restores or edits nothing. It follows `projectChanged` of the sequence, reading again only
|
||||
the changed projects' open versions (as many as are shown), and reads everything again
|
||||
after a reconnection. The table drops columns at narrow widths.
|
||||
- `#/library?view=trash`, also opened from Archive: the trash's entries (kind, sequence,
|
||||
photos, size, deleted by and when), each with *Restore*, whose answer says which photos
|
||||
stayed and why; *Empty…* measures the trash (dry run), lists what goes, asks for the word
|
||||
@@ -2770,6 +2914,7 @@ questions asked and the answers; DECISIONS rows give the reasons.
|
||||
| 2026-10-26 | Owner review 2, R7 (naming) | §7.1, §13, §14.3 | One naming rule for import, upload and Reorganize: the sequence's camera and lens, `{n}` its place, a frame without a time at the sequence's start; template rules everywhere a template is typed or sent (no folder level scans skip, one a value such as a title gives escaped with `_`; a file template keeps the extension, tells photos apart, holds no slash; long names shortened before `.{ext}`; titles as text), held to a template only when it is given anew; `invalid_template` names the rule. |
|
||||
| 2026-10-26 | Owner review 2, R7 (conversion) | §5, §7, §8.1, §8.3, §8.7, §9, §12.2, §12.4, §12.5, §13, §14.3, §14.4, §14.5, §14.8, §14.9 | Convert after import on the desktop (the Archive manager's set, the Library's selection) and the admin panel (the Library's selection): JPEG with a quality, TIFF-16 or linear DNG (the archival choice, scene-referred so a RAW's highlights above white and colours outside sRGB survive), Replace or New sequence chosen at every run and never remembered, behind a dry run that lists each sequence's photos, sizes and the photos that stay as they are with why, and the free space where the conversion writes; Replace confirmed by typing; the `convert` job (stored as 19) converts exactly the photos confirmed, one sequence at a time and all or nothing, resumable through its journals and staging, never twice at once; full-resolution decodes only (the managed decoders first, never a 16-bit file from an 8-bit RAW development; the server leaves what it cannot read to a PC), what Chronos reads from a photo never changed (profiles carried, a linear DNG of sRGB values only), Exif carried, every file verified by the server's decoders; Replace swaps the files of the frames in place under a crash-safe journal, the originals going into a replaced trash entry that Undo or Restore swaps back and that Empty erases only while the archive on disk shows each conversion intact, or deleted on its own word (a tombstone, the trash, an erasure record); import still copies byte for byte and the card keeps a converted photo's copy; sync and the ingest count every encoding of a photo as one; `POST /api/v1/archive/convert` with the plan cache it shares with Reorganize, `sequenceChanged` `converted` and `created`, the audit `archive_converted`. |
|
||||
| 2026-10-26 | Owner review 2, R8 (phase 5a: workspace and projects, local home) | §4.4, §5, §7, §12.2, §12.3, §12.6, §12.8, §14.5, §14.6 | A sequence's home (this PC's archive) keeps its projects: Main, mirrored both ways with the sequence's settings so older clients and sync keep working, and other named projects, each a linear history of immutable versions in the portable form (positions parked by photo, SHA-256 of canonical text), stored as sidecars in `.chronos/projects/` and indexed by migration 0009 (`projects`, `project_versions`, `renders.project_id`/`project_version_id`); deletions only on the archive's word, the trash read first; Edit opens only workspace projects: *Open in workspace* (project, proxies), the `workspace-copy` job (stored as 20, desktop only, hash-verified, resumable, space checked), the working state in a folder outside the library, the project button with its state chip and menu (Save version, Sync, History with Compare and Restore, Open, New, Rename, Delete, Remove local copy), push and pull with replay and field-level merge, conflicts only when both sides changed a setting (Keep mine, Take library's, Save both, Later), renders at the home with the settings embedded; Settings › Workspace (folder, sync, kept versions). The server home is phase 5b; originals, local render, clean-up and the rest of Settings › Workspace are phase 5c. |
|
||||
| 2026-10-26 | Owner review 2, R8 (phase 5b: server home) | §4.4, §7, §12.2, §12.3, §12.7, §14.3, §14.5, §14.7, §14.8 | A Chronos Server keeps its sequences' projects as a PC's archive does: `/api/v1/sequences/{sid}/projects` (list with Main made at the first read, create, rename, delete with the owner's, maker's or an admin's right, head, versions in size-capped pages, stored check, push with its outcome, frames and their stamp), the `projects` capability and `projectChanged`; settings written outside the projects become Main's version soon after, and a settings `PATCH` writes `project.json` under the lease; a sequence without photos keeps no projects; renders and render nodes take a project version's settings and record it; the admin panel's sequence page lists the projects (versions, Rename, Delete). The desktop opens a server sequence as a workspace project through its sign-in: *Open in workspace* on the Server screen and in Edit, proxies downloaded into the workspace (hash-checked, resumable), push and pull, conflicts, history and live state against the server, texts naming the server, renders and analyses on the server of the version it holds; an account without Edit and an older server keep *Open with proxies*. |
|
||||
| 2026-11-04 | Owner review 3 (ports) | §12.7, §14.8, §14.9, §15, §19.6 | The public HTTP/HTTPS ports are server settings as well as variables (a variable locks them), applied at once; in a container the listening ports are locked to the template's; the admin panel's Network and TLS shows the container's ports, the public ports and the client address with Copy; clients read an address without scheme or port as port 8443 and report an address that answers as something else, never offering its certificate for trust; the Unraid template and compose gain *Public HTTP port*. |
|
||||
|
||||
## Appendix A — `CLAUDE.md` content (create verbatim in Phase 0, keep updated)
|
||||
|
||||
+43
-17
@@ -6,25 +6,39 @@ commits follow Conventional Commits (release notes are generated from them by `C
|
||||
## [Unreleased]
|
||||
|
||||
### Added
|
||||
- A Chronos Server keeps its sequences' projects (owner review 2, phase 5b): Main and named projects with their
|
||||
versions, under `/api/v1/sequences/{id}/projects`, with `projectChanged` events and the `projects` capability. The
|
||||
admin panel lists a sequence's projects.
|
||||
- Edit opens a server's sequence as a workspace project, as for this PC's library: *Open in workspace* asks which
|
||||
project, its proxies are downloaded into the workspace (hash-checked, resumable), and Save version, Sync, History,
|
||||
New, Rename, Delete and Remove local copy work against the server. A project already in the workspace opens while
|
||||
the server is out of reach; its work waits. The chip follows what the server says (*Server newer*, *Not on
|
||||
server*), texts name the server, analyses and renders run on the server, and a render first offers to send what is
|
||||
not there yet.
|
||||
- **Server home** (owner review 2, R8, phase 5b): a Chronos Server keeps its sequences' projects, as a PC's archive
|
||||
does: Main and named projects, each with its versions, under `/api/v1/sequences/{id}/projects`. The server lists the
|
||||
capability `projects` and tells connected programs of every change (`projectChanged`). Settings changed by an older
|
||||
Chronos, an analysis, the sync of a desktop's copy or a conversion become a new version of the sequence's Main soon
|
||||
after.
|
||||
- Sequences of a Chronos Server open in the workspace, as this PC's do: *Open in workspace* (in Edit, and on the
|
||||
Server screen) asks which project, and its proxies are downloaded into the workspace (hash-checked, resumable).
|
||||
Save version, Sync, conflicts, History and Restore, New, Rename, Delete and Remove local copy work against the
|
||||
server. A project already in the workspace opens while the server is out of reach or this PC is signed out; its
|
||||
work waits (*Offline*). An account without Edit opens the server's sequences with proxies, read-only, as before.
|
||||
- A project's chip shows at once when someone changed it on the server (*Server newer*) or deleted it there (*Not on
|
||||
server*; your copy and unsent versions are kept); a rename on the server reaches the copy. Texts name the server.
|
||||
- Analyses and renders of a server's project run on the server. A render renders the version the server holds, and
|
||||
first offers *Send and render* for changes not sent yet.
|
||||
- The admin panel's sequence page lists its projects: who changed each last and when, its versions (20 at a time,
|
||||
*Load more*), and *Rename…* and *Delete…* for projects other than Main.
|
||||
- Renders can be of a project version: the server and render nodes render that version's settings and record the
|
||||
project and the version with the render.
|
||||
- Known limitations: projects name the server by the address they were made with, so signed in through another
|
||||
address (its IP instead of its name) they read *Offline*; a copy reads the server's frames in one answer (about
|
||||
35 MB at 100,000 photos); *History* downloads every version's settings; downloads into the workspace are not paused
|
||||
on a metered connection (only uploads are); originals in the workspace and local renders are phase 5c.
|
||||
|
||||
### Fixed
|
||||
- Server projects (review of phase 5b): a sequence without photos no longer writes projects at the archive's root
|
||||
(*This sequence has no photos yet.*); a full-size version can be pushed and one too large is told so; version pages
|
||||
are capped in size; a settings change sent to the server is no longer lost when Main is made later; deleting a
|
||||
project as its maker needs the same account, not just the same name; renames, rescans and reconnects reach the
|
||||
workspace; a status no longer downloads the server's frames each time; a resumed copy never keeps a thumbnail as a
|
||||
proxy; an account without Edit opens server sequences with proxies; a project opened signed out renders once signed
|
||||
in. The admin panel's projects table fits narrow windows, keeps the versions loaded with *Load more* on a live
|
||||
refresh and no longer downloads settings it does not show.
|
||||
- Server home, found by the phase's review before any release had them (one adversarial round, 21 findings, 19
|
||||
fixed): a sequence without photos no longer writes projects at the archive's root (*This sequence has no photos
|
||||
yet.*); a full-size version can be pushed and one too large is told so; version pages are capped in size; a
|
||||
settings change sent to the server is no longer lost when Main is made later; deleting a project as its maker needs
|
||||
the same account, not just the same name; renames, rescans and reconnects reach the workspace; a status no longer
|
||||
downloads the server's frames each time; a resumed copy never keeps a thumbnail as a proxy; an account without Edit
|
||||
is never offered *Open in workspace*; a project opened signed out renders once signed in. The admin panel's
|
||||
projects table fits narrow windows, keeps the versions loaded with *Load more* on a live refresh and no longer
|
||||
downloads settings it does not show.
|
||||
- Chronos and the Uploader could not reach a server in a container whose ports are published as other host ports
|
||||
(owner review 3). The admin panel's Settings › Network and TLS listed the container's ports (8080, 8443) as if
|
||||
clients used them. In a container it now shows them read-only as *Container HTTP port* and *Container HTTPS port*,
|
||||
@@ -46,6 +60,18 @@ commits follow Conventional Commits (release notes are generated from them by `C
|
||||
- A link-local IPv6 address with a zone (`fe80::1%12`) is refused as an invalid address instead of losing its zone.
|
||||
|
||||
### Changed
|
||||
- On a Chronos Server, a `PATCH` of a sequence's settings also writes the sequence's `project.json`, under the
|
||||
sequence's lease (owner review 2, R8). While another job holds the sequence for more than 20 s, its archive is
|
||||
offline or its folder moved, it now answers 503 (`sequence_busy`, `archive_offline`, `folder_moved`) or 409
|
||||
`folder_in_use` and changes nothing; the desktop's sync tries again at its next comparison. A `PATCH` of title,
|
||||
tags, rating or notes alone is unchanged.
|
||||
- Server screen: on a server that keeps projects, *Open in workspace* replaces *Open with proxies* for an account with
|
||||
Edit; on an older server it is shown disabled, its tooltip saying the server needs an update.
|
||||
- **Upgrade:** the server home needs this release on both the server and the desktop. Chronos uses a server's
|
||||
projects only when its `server/info` lists `projects`; with an older server, Edit opens its sequences with proxies
|
||||
as before. Older Chronos versions keep working with a new server: they ignore `projectChanged`, and their settings
|
||||
edits become Main's versions. No migration runs (0009 came with phase 5a). The first open of a server's sequence
|
||||
in Edit downloads its proxies into the workspace.
|
||||
- The public ports are server settings: edited in the admin panel and applied at once to LAN discovery and the
|
||||
redirect to HTTPS, or set by `CHRONOS_PUBLIC_HTTP_PORT` / `CHRONOS_PUBLIC_HTTPS_PORT`, which lock them. In a
|
||||
container the listening ports change only through `CHRONOS_HTTP_PORT` / `CHRONOS_HTTPS_PORT`; a port saved for them
|
||||
|
||||
+43
-24
@@ -573,7 +573,7 @@ One line per decision: date · decision · alternative · reason.
|
||||
| 2026-11-03 | Newer settings format: settings of a newer format open read-only (`FromJson(json, allowNewer: true)`, `IsNewerFormat`); a format 1 project file still refuses them. They are never merged with this format's (`NewerSettingsException` when both sides changed): a newer Main head is listed and pulled but never mirrored, merged or built on (`MirrorAsync` reads leniently and skips it), pushes must parse strictly, and the editor drops its undo steps rather than rebase them onto newer settings. (Owner review 2, R8, fix rounds 1–2.) | Refuse such settings everywhere; merge member by member | A workspace must show what a newer Chronos pushed without misreading or overwriting it, and undo must never bring this Chronos's values back over the newer ones. |
|
||||
| 2026-11-03 | Project file format 2: `ProjectBundle` is written as format 2 only with a `workspace` section (project id, name, Main, home, base version id, number and hash, media kind and frames version); a file without it is still written as format 1. `IsReadOnly` marks a project of a newer settings format. (Owner review 2, R8.) | Always format 2 | Earlier Chronos versions keep opening the project files users save. |
|
||||
| 2026-11-03 | Size limits: `ProjectBundle.MaxBytes` and `ProjectSidecars.MaxVersionBytes` are both 64 MiB, one limit for writing and reading, refused before anything is written (`ProjectTooLargeException`, `Errors.Project.TooLarge`; `ProjectVersionTooLargeException`; `PushOutcome.TooLarge`, appended last, shown as `Errors.Workspace.VersionTooLarge`). A 100,000-frame sequence with every frame parked takes about 26 MB. (Owner review 2, R8, fix rounds 1–2.) | 4 MiB for project files and 8 MiB for versions (the first version) | Large projects could not be checked out, and a version written that no read takes back was lost silently. |
|
||||
| 2026-11-03 | Main mirroring: Main is made lazily (`MainAsync`) from the sequence's settings (`project.json` first) as version 1, Imported; its head is mirrored into `project.json` and the index's settings with the settings version check; the record's `mirrored` names the version `project.json` was last known to hold. Settings any other path writes (an older Chronos, the editor's old path, an analysis, the API, sync) become an External version of Main at the next project call; a mirror a crash cut short is completed. (Owner review 2, R8.) | Migrate every sequence; an API version bump | Older clients and the server's settings sync keep working unchanged, and no migration pass runs over large archives. |
|
||||
| 2026-11-03 | (Partly superseded by the 2026-10-26 `ProjectCatchUp` row: on a server, settings written outside the projects become Main's version soon after, for sequences that have a Main.) Main mirroring: Main is made lazily (`MainAsync`) from the sequence's settings (`project.json` first) as version 1, Imported; its head is mirrored into `project.json` and the index's settings with the settings version check; the record's `mirrored` names the version `project.json` was last known to hold. Settings any other path writes (an older Chronos, the editor's old path, an analysis, the API, sync) become an External version of Main at the next project call; a mirror a crash cut short is completed. (Owner review 2, R8.) | Migrate every sequence; an API version bump | Older clients and the server's settings sync keep working unchanged, and no migration pass runs over large archives. |
|
||||
| 2026-11-03 | Main catch-up merge: a push whose mirror a crash or a race cut short, met by settings written meanwhile by another path, becomes ONE Merge version on the head, in which the settings written meanwhile win where both changed; the push's values stay in its own version. A merge that holds nothing the head lacks makes no version and the head is mirrored, so a merge cut before its mirror is finished next time by the same index or a rebuilt one. (Owner review 2, R8, fix round 3; supersedes rounds 1–2's External and Merge pair.) | An External version, then a Merge, resumed by their shape; the push wins | The settings written meanwhile are the newer write, in force, and what older clients wrote and read; the pair's resume misfired on ordinary histories and reverted the latest edit. |
|
||||
| 2026-11-03 | An index meeting Main with no mirror known decides from `project.json`, never from its own settings column: the record's `mirrored` is a lower bound, `project.json` matching any version from the head down to it completes the mirror, a record naming the head or no version gives an External, and one naming an older mirror that `project.json` matches nowhere merges (`project.json` wins where both changed). When the catch-up records a version as mirrored and `project.json` holds it, the record names it too. (Owner review 2, R8, fix rounds 1–3.) | Compare with the index's settings column | That column can be stale on a second PC or after a backup, and taking it as an outside change reverted pushed heads. |
|
||||
| 2026-11-03 | A mirror never writes `project.json` over settings written there since this index last knew what it held (the version mirrored, the settings just taken in, the index's or the record's mirrored version): it takes them in first (External, or a merge where they win), then mirrors; if `project.json` moves again meanwhile, nothing is written and the next call catches up. A `project.json` that cannot be read is written over as before. (Owner review 2, R8, fix round 4.) | Write the mirror unconditionally | An edit another PC or an older client made only in `project.json` would be lost, its values in no version. |
|
||||
@@ -596,7 +596,7 @@ One line per decision: date · decision · alternative · reason.
|
||||
| 2026-11-03 | The frames stamp: a workspace status reads the home's frames again only when `IProjectHome.FramesStampAsync` changes (the archive's: frames version, hashed-frame count, a checksum of the hashes, removal count); a home without a stamp is read every time, and a sync's replay always reads them. (Owner review 2, R8, fix rounds 3–4.) | Read every frame at every status | The picker reads a state per project; a large sequence must not be loaded each time, yet a hash replaced in place must be seen. |
|
||||
| 2026-11-03 | Workspace states: In sync, Changed, Not sent, Library newer, Conflict, Offline, No media, Not in library (`Gone`: the home has no such project or sequence; push, pull and resolve return it without replaying anything, it is logged once, it carries no conflict, and the copy goes only by Discard) and Damaged (a version file after the base cannot be read or breaks the chain: commit, push, pull, resolve and Save both are blocked, the file is repaired from the home's verified copy when it has one, and it is reported only once a re-read under the lease confirms it). A read-only library is named so (`Errors.Workspace.ReadOnlyHome`), not offline. (Owner review 2, R8, fix rounds 1–4.) | Offline for every failure | The user sees why nothing is sent and what settles it. |
|
||||
| 2026-11-03 | Damaged and newer copies: a copy whose `project.chronos` a newer Chronos wrote (a format above 2) is listed as *Newer Chronos* and is never opened, checked out over or removed from here; one that cannot be read is *Damaged* and goes only by Discard. Both are named by what is still known (the file read loosely, else the index's project name or sequence title); discarding a damaged one asks for that name, else its number of files. Open in workspace with such a Main lists it disabled with its reason (`Tooltips.Editor.Workspace.State.NewerCopy` or `DamagedCopy`) and selects the first readable project; it refuses at once only when Main was asked for or the home has no other project, a damaged Main then offering Remove local copy. (Owner review 2, R8, fix rounds 2–5.) | Hide them; refuse the whole open | A newer format is never fatal for the rest of the workspace, nothing in such a copy is changed, and the other projects of the sequence still open. |
|
||||
| 2026-11-03 | Edit opens workspace projects: a sequence of this PC's archive opens in Edit only as a workspace project, the one opened last for it on this PC (`AppSettings.WorkspaceRecent`), else *Open in workspace* (Project: existing or new; Media: Proxies, Originals disabled until 5c; copy size and free space, warned below size + 0.5 GB). Edit waits for the Workspace copy job as for a server sequence's proxies. A capture keeps `LocalSequenceSource`; server sequences keep `RemoteSequenceSource` until 5b. (Owner review 2, R8.) | Ask at every open; edit the library | One project is worked on at a time; the library is never edited in place; a capture has no engine to copy media. |
|
||||
| 2026-11-03 | (Partly superseded by the 2026-10-26 Edit opens a server's sequence row: a sequence of a server that keeps projects opens as a workspace project; an older server's keeps `RemoteSequenceSource`.) Edit opens workspace projects: a sequence of this PC's archive opens in Edit only as a workspace project, the one opened last for it on this PC (`AppSettings.WorkspaceRecent`), else *Open in workspace* (Project: existing or new; Media: Proxies, Originals disabled until 5c; copy size and free space, warned below size + 0.5 GB). Edit waits for the Workspace copy job as for a server sequence's proxies. A capture keeps `LocalSequenceSource`; server sequences keep `RemoteSequenceSource` until 5b. (Owner review 2, R8.) | Ask at every open; edit the library | One project is worked on at a time; the library is never edited in place; a capture has no engine to copy media. |
|
||||
| 2026-11-03 | Workspace editor saves: the working state is saved atomically under the project's lease shortly after an edit, merged in the portable form, photo by photo, whenever positions conflict; a setting the editor and a sync both changed throws `ProjectConflictException` and is asked (keep mine, take the library's). A read-only project raises `ReadOnlyChanged`: a toast, disabled controls, no save. An edit not stored yet that meets a newer Chronos's settings is written to `versions/.replaced` (*Edit kept aside*) and the pending save dropped. The chip is read 600 ms after the last edit. (Owner review 2, R8, fix rounds 1–3.) | Positional merge, the editor winning | Exclusions, keyframes and values a sync just pulled are never dropped silently. |
|
||||
| 2026-11-03 | Sync: Sync is pull, then push, then prune. With *Sync automatically* (on by default) it also runs after Save version and after an analysis while the project is behind, so Main takes the analysis' Auto values. Ctrl+S opens Save version with the note focused; Enter saves. A home out of reach leaves the version waiting. (Owner review 2, R8.) | Push only; a silent Ctrl+S | The local home is always at hand, and the editor keeps showing analysis results as before the workspace. |
|
||||
| 2026-11-03 | Kept versions: pruning keeps the base and the newest N−1 other versions taken from the home, and deletes a version file only after `HoldsAsync` finds the home's copy with the same hash; versions not sent and `versions/.replaced` are never touched. It runs after each sync; N is Settings › Workspace › Kept versions (5–200, default 20). (Owner review 2, R8.) | Prune in 5c; prune without asking the home | The setting is part of 5a, and pruning without the read-back could lose a version. |
|
||||
@@ -604,7 +604,7 @@ One line per decision: date · decision · alternative · reason.
|
||||
| 2026-11-03 | Delete project commits and sends everything first, refuses while anything stays unsent or in conflict, then deletes at the home (the projects' trash) and removes the local copy; Main cannot be deleted; at Gone it says the project was deleted in the library. (Owner review 2, R8.) | Delete at once | Every version survives in the library's project trash. |
|
||||
| 2026-11-03 | Workspace copy: the job (desktop only, `WorkspaceJobs.CreateHandlers`) runs the archive's proxy pass, copies current proxies, makes the rest in the workspace at 1920 px when the archive makes none, and reads each file back. It writes `media.json` last and moves the working positions by photo under the project's lease for that step only; it starts again when the frames change (3 passes). Its checkpoint is `copy:<frame>:<frames version>:<folder>`; changed bytes go under `proxies/<id>-<sha16>.jpg` until the commit, and no file `media.json` names is deleted before it. Free space: an estimate per frame (0 when held, the archive proxy's size, else 1.5 MB × (edge/1920)²) plus 512 MiB, checked before each pass and every 5 s (`Errors.Workspace.DiskFull`). Default level High. Originals are refused until 5c. (Owner review 2, R8, fix rounds 1–4.) | Copy originals; hold the lease throughout; trust a resumed file | Fast editing on proxies while the editor keeps saving; a resume after a move or a conversion checks every file; the system drive never fills. |
|
||||
| 2026-11-03 | The copy job's cancel clean-up: a cancelled first copy clears `media/` only under the project's lease, taken without creating a folder, after checking again that the job is still Cancelled, that no other WorkspaceCopy of the same root (full path, case-insensitive) and project is Queued, Running or Paused (one whose parameters cannot be read counts), that `media.json` is absent and that no copy in this process is writing; otherwise the media stay, with an Info line. It runs from the handler once it has stopped writing, or through the new `ICancelledJobHandler` for a paused or failed job no handler runs; `JobEngine.CancelAsync` of a paused job whose run has not ended waits for that run first. Paused, yielded and shut-down copies keep their files. (Owner review 2, R8, fix rounds 2–5.) | The section's view model deletes the media when the job reads Cancelled | The view model raced the stopping copy and missed a copy nobody watched; a second copy of the same project must keep its files. |
|
||||
| 2026-11-03 | Workspace renders: a render from Edit of a workspace project runs on this PC's engine at the home, with the originals and the portable settings embedded (`RenderJobParameters.SettingsJson`, the handler placing pending frames first), one job per preset. The desktop names a version only while none waits to be sent; `RenderJobHandler.ProvenanceAsync` records the project only if it is one of the sequence, and the version only if the index holds it for that project with the embedded settings' content hash. (Owner review 2, R8, fix round 1.) | Commit before rendering; record any version id | A render never invents a version nor names one whose settings it did not use, or that a later replay renames. |
|
||||
| 2026-11-03 | (Partly superseded by the 2026-10-26 server render row: a project whose home is a server renders on the server, the version the server holds.) Workspace renders: a render from Edit of a workspace project runs on this PC's engine at the home, with the originals and the portable settings embedded (`RenderJobParameters.SettingsJson`, the handler placing pending frames first), one job per preset. The desktop names a version only while none waits to be sent; `RenderJobHandler.ProvenanceAsync` records the project only if it is one of the sequence, and the version only if the index holds it for that project with the embedded settings' content hash. (Owner review 2, R8, fix round 1.) | Commit before rendering; record any version id | A render never invents a version nor names one whose settings it did not use, or that a later replay renames. |
|
||||
| 2026-11-03 | `.chronos` files: format 2 opens its workspace project (a copy of one gives that project its settings as one undo step; a project the home lacks falls back to Main); format 1 gives its settings to the sequence's Main, opened in the workspace. *Save project file* still writes format 1. (Owner review 2, R8.) | Refuse format 1 | Older files and the file association keep working. |
|
||||
| 2026-11-03 | Edit picker: the workspace's projects (saved last first) above the library's sequences; each state is read from its home after the list shows; the search filters both; Enter opens a library match first, a project only when no sequence matches. A row's context menu and Delete offer Remove local copy, also for a copy that cannot open. (Owner review 2, R8.) | One merged list | The picker's keyboard behaviour and paging stay as they were. |
|
||||
| 2026-11-03 | Settings › Workspace (after Storage): *Folder* with *Open* and *Change…* (a plan, projects left and found; it closes an open workspace project and moves nothing; the default is stored as no setting), *Sync* (After each version, on) and *Kept versions*. Reset all and Import keep `WorkspaceFolder` and `WorkspaceRecent`; Export leaves them out. Moving the folder with its projects, the size limit and the plan's other settings are 5c. (Owner review 2, R8, fix round 2.) | An editable path that moves the projects now | The folder holds this PC's unsent work: moving it needs its own plan and confirmation. |
|
||||
@@ -626,24 +626,43 @@ One line per decision: date · decision · alternative · reason.
|
||||
| 2026-11-04 | `ChronosAddress` refuses a link-local IPv6 address with a zone index (`fe80::1%12`): *Invalid address*. | Keep the zone as `%25` | `Uri` and the connection would drop the zone, failing later with a less clear error; the LAN address or name works. |
|
||||
| 2026-11-04 | Screenshot baselines are captured on the development PC (Europe/Rome time zone) from a Release build and committed to `tests/visual/baselines` (156 screens, owner review 3, R2); CI no longer pushes its screenshots to a `ci-screenshots` branch, the branch is deleted, and the `windows` job's token is read-only. Until a Windows runner is registered (on that PC, or a new set accepted from the runner's PC), `screenshots diff` runs locally before a pull request that changes a screen. | Keep accepting from `ci-screenshots`; merge that branch | The owner chose it: no Windows runner exists, so CI never produced a set taken at `SampleData.Now`, and the old `ci-screenshots` commit predates the fixed clock; a branch that only CI writes and that never merges is noise once baselines live in `main`. |
|
||||
| 2026-11-04 | While `--capture` freezes `AppClock`, what the screens measure on the machine is shown as fixed sample values: free space 1.2 TB (`ArchiveLocations.FreeSpace` and the import plan's totals), a server latency of 12 ms, and the last sync comparison at the frozen moment taking 0.4 s. | Raise the diff tolerance; leave them measured | Measured, they moved the Server screens by 0.13–0.15 % (the latency's width shifts the rest of the status line) and the Import screens to the 0.05 % limit (the PC's free space), so baselines failed at random; a larger tolerance would hide real changes. |
|
||||
| 2026-11-04 | Server home (owner review 2, R8, phase 5b): a server sequence's projects live under `/api/v1/sequences/{id}/projects` (list, create, rename, delete, head, versions, push, frames) on the same `ProjectService` as a PC's archive, gated by the `projects` capability; the desktop reaches them through `ServerProjectHome` over the signed-in session's `ChronosClient`. A server out of reach, an expired sign-in, a 503 (busy lease, offline archive, `projects_unreadable`), a 409 `folder_in_use` and a server without the projects are `HomeUnavailableException` (the workspace shows Offline and its work waits); a 404 `sequence`/`project`/`version` and a refused name are `ProjectException`s; other refusals keep their `ChronosApiException`. | A separate server-side project store | One implementation of the rules 5a hardened (leases, sidecars, journals, merges); the workspace treats both homes alike. |
|
||||
| 2026-11-04 | A deleted project's head answers 404 `project` on the server, as `IProjectHome.HeadAsync` answers NotFound on a PC's archive (5a): the workspace reads Gone from the head alone. The original 5b's `IProjectHome.IsLiveAsync` and `WorkspaceStatus.Gone` are dropped in the port. | Keep the head readable and ask `IsLiveAsync` (the original 5b) | Final 5a already decides Gone from the head; one rule for both homes, and one request fewer per status. A deleted project's versions stay readable (`/versions`). |
|
||||
| 2026-11-04 | Push outcomes gain `too_large` (422, `PushOutcome.TooLarge`, final 5a's 64 MiB limit), a version over the limit read by the server is 413 `too_large`, and `ProjectsUnreadableException` is 503 `projects_unreadable`; both are caught before the `IOException` → 409 `folder_in_use` mapping. The workspace words them for the home (`Errors.Workspace.VersionTooLarge.Server`). | Let them fall through as `folder_in_use` | They are not a folder in use: too large is final, unreadable is worth retrying. |
|
||||
| 2026-11-04 | `ProjectService` tells what each call changed (`ProjectChangeSet` to `ArchiveServiceOptions.ProjectsChanged`) after the lease is let go, compared from the projects read before the reconcile and after the call; the server turns it into `projectChanged` events and its background `ProjectCatchUp` runs `CatchUpAsync`. The catch-up of a read-only archive (`ReadOnlyCatchUpAsync`) tells nothing. | Tell inside the lease; diff the index | Subscribers never run under a sequence's lease; the before/after read is the only one that sees records the reconcile healed. |
|
||||
| 2026-11-04 | Kept versions on a server home are pruned as on a PC's archive: each version file goes only after `HoldsAsync` read that version back from the home with the same hash (one request per version). | One listing of the server's versions (the original 5b) | Final 5a's rule: a listing does not prove the stored bytes; pruning is rare and small. |
|
||||
| 2026-11-04 | The workspace copy of a server's sequence (`WorkspaceJobs.CopyFromServer`) downloads through the desktop's session (`ISyncConnector`), never this PC's archive: one frames version with its aliases, each proxy (else the thumbnail standing in, `FileKind` thumb) hashed as it arrives and checked on disk, four at a time, resumable from final 5a's `copy:frame:fv:folder` checkpoint, the editor's current file never overwritten (other bytes under `ProxyName(id, sha)`), the space checked against the server's proxy sizes (the manifest has no file sizes), a cancelled first copy cleared like 5a's. | Copy through the proxy cache | The cache is the proxy editor's; the workspace owns its media. |
|
||||
| 2026-11-04 | Texts of a server's project are their key's `.Server` form when one exists (`WorkspaceText.ForHome`), else the key itself; the chip says *Server newer* and *Not on server*. | Format "the library" / "the server" into one text | Word order and articles differ by language; a missing form falls back to the library's text, never to a key. |
|
||||
| 2026-11-04 | A server's project renders what the server holds: before a render (`ProjectMenuViewModel.ReadyToRenderAsync`) unsaved or unsent work is offered to be saved and sent; Offline, Gone, Damaged or media removed hold the render. In step, the jobs name the version alone; out of step, the portable settings travel and only the project is recorded. An analysis's Auto values reaching Main at the server are taken by the next `projectChanged` (pushed) within 2 minutes, with Sync automatically. | Render the workspace's settings always | The server renders with its originals; only a version it holds can be named. |
|
||||
| 2026-11-04 | Edit opens a server's sequence as a workspace project when the server has the `projects` capability (`OpenServerWorkspaceAsync`), with final 5a's refusals (a copy this Chronos cannot read, a damaged or newer Main listed disabled, a workspace folder refused). The *sequence left the index* refusal applies only to projects of this PC's archive. An older server's sequences open with proxies as before. | Refuse every project whose sequence is not in the index | A server's sequence is never in this PC's index. |
|
||||
| 2026-11-04 | `ServerProjectHome` reads the frames stamp from `GET …/projects/frames/stamp` (`ArchiveProjectHome.StampOfAsync` on the server), so a status downloads the server's frames only when the stamp moved. Supersedes "no frames stamp" of the first 5b port. | Read the frames each time | Review 5b: every status of every server project downloaded the whole frame list. |
|
||||
| 2026-11-04 | A sequence without a folder (a server's sequence made before its first photo) keeps no projects: it lists none, `CreateAsync` and every other change refuse with `ProjectError.SequenceEmpty` (409 `sequence_empty`) before any lease or file, and the stored-version check answers false. The desktop says *This sequence has no photos yet.* | Make Main in the index only | Its folder is empty, so the sidecars and leases landed at the archive's root. |
|
||||
| 2026-11-04 | A settings PATCH on the server writes the sequence's `project.json` under the sequence lease first (`ArchiveService.EditSettingsAsync`, 20 s wait), then the index; the file is put back when the index does not take the edit. Busy, offline and moved answer 503 (`sequence_busy`, `archive_offline`, `folder_moved`), a file in use 409 `folder_in_use`. A PATCH of title or tags alone stays index-only. | Make Main's birth prefer the index | 5a's Data tests make `project.json` win on the desktop; the PATCH was the one writer that left it behind. |
|
||||
| 2026-11-04 | The push body limit is the version limit (64 MiB) plus 1 MiB; the client reads a 413 as `ProjectPushOutcomes.TooLarge` / `too_large`. Version pages stop once their settings add up to 4 Mi characters (always one version at least) and say `more`; `ServerProjectHome` pages on until it has what was asked. `summary=true` leaves the settings out (the admin panel). | One fixed page size | A page of 200 large versions was hundreds of MB. |
|
||||
| 2026-11-04 | Deleting a project as its maker needs the same account: same username, and an account made no later than the project. | Store the maker's id | No schema change; a name reused by a newer account no longer inherits the rights. |
|
||||
| 2026-11-04 | `projectChanged` is also told for a full rescan's reconcile and the read-only catch-up (compared around them, told after the lease), and a Main flip reads as `renamed`. | Tell only the API's own calls | Another PC's changes reached the workspaces only at their next read. |
|
||||
| 2026-11-04 | `SyncAgent` tells "changes may have been missed" only once the event stream is open again (`ISyncRemote.EventsAsync(connected, ct)`) and the refresh after it ran. | Tell at the loss | Told before the stream was back, a workspace re-read too early and missed changes made in between. |
|
||||
| 2026-11-04 | A server-side rename reaches the workspace copy: every pull and the `renamed` event write the home's name (and Main) into the bundle (`WorkspaceSync.FollowNameAsync`), errors ignored. | A new `IProjectHome.ProjectAsync` | `ListAsync` already answers; one call fewer to add to both homes. |
|
||||
| 2026-11-04 | `ServerProjectHome.HoldsAsync` reads the version file back (`GET …/versions/{id}?stored=true`, `ProjectService.StoredAsync`), false when the file is missing or damaged, or the project deleted. | Trust the index row | Pruning a local version needs proof the server's file holds it. |
|
||||
| 2026-11-04 | A copy from a server writes an empty `<file>.thumb` marker before a thumbnail taken for a missing proxy is moved into place; a resumed run reads it (and downloads the proxy when the server has it now); the commit removes the markers. | Download again every file of unknown kind | A resume would fetch every frame again. |
|
||||
| 2026-11-04 | An account without Edit is offered *Open with proxies* (read-only) on a server that keeps projects, never *Open in workspace*, and Edit checks nothing out for it; a copy the workspace already holds still opens, its pushes refused (403) as a refusal, not as Offline. | Check out read-only | A viewer's workspace copy could never be pushed. |
|
||||
| 2026-11-04 | The editor of a server's workspace project connects with the sign-in in use at each use (`WorkspaceServerHome(connect, session)`): a sign-in, sign-out or new sign-in drops the old connection and its jobs. `SyncHost` tells each session start and stop as `ProjectChanged(server, null)`. | Rebuild the editor | A project opened signed out could not render after signing in. |
|
||||
| 2026-10-26 | Server home (owner review 2, R8, phase 5b): a server sequence's projects live under `/api/v1/sequences/{id}/projects` (list, create, rename, delete, head, versions, push, frames) on the same `ProjectService` as a PC's archive, gated by the `projects` capability; the desktop reaches them through `ServerProjectHome` over the signed-in session's `ChronosClient`. A server out of reach, an expired sign-in, a 503 (busy lease, offline archive, `projects_unreadable`), a 409 `folder_in_use` and a server without the projects are `HomeUnavailableException` (the workspace shows Offline and its work waits); a 404 `sequence`/`project`/`version` and a refused name are `ProjectException`s; other refusals keep their `ChronosApiException`. | A separate server-side project store | One implementation of the rules 5a hardened (leases, sidecars, journals, merges); the workspace treats both homes alike. |
|
||||
| 2026-10-26 | A deleted project's head answers 404 `project` on the server, as `IProjectHome.HeadAsync` answers NotFound on a PC's archive (5a): the workspace reads Gone from the head alone. | Keep the head readable and ask a separate `IsLiveAsync` | 5a already decides Gone from the head; one rule for both homes, and one request fewer per status. A deleted project's versions stay readable (`/versions`). |
|
||||
| 2026-10-26 | Push outcomes gain `too_large` (422, `PushOutcome.TooLarge`, final 5a's 64 MiB limit), a version over the limit read by the server is 413 `too_large`, and `ProjectsUnreadableException` is 503 `projects_unreadable`; both are caught before the `IOException` → 409 `folder_in_use` mapping. The workspace words them for the home (`Errors.Workspace.VersionTooLarge.Server`). | Let them fall through as `folder_in_use` | They are not a folder in use: too large is final, unreadable is worth retrying. |
|
||||
| 2026-10-26 | `ProjectService` tells what each call changed (`ProjectChangeSet` to `ArchiveServiceOptions.ProjectsChanged`) after the lease is let go, compared from the projects read before the reconcile and after the call; the server turns it into `projectChanged` events and its background `ProjectCatchUp` runs `CatchUpAsync`. | Tell inside the lease; diff the index | Subscribers never run under a sequence's lease; the before/after read is the only one that sees records the reconcile healed. |
|
||||
| 2026-10-26 | Kept versions on a server home are pruned as on a PC's archive: each version file goes only after `HoldsAsync` read that version back from the home with the same hash (one request per version). | One listing of the server's versions | Final 5a's rule: a listing does not prove the stored bytes; pruning is rare and small. |
|
||||
| 2026-10-26 | The workspace copy of a server's sequence (`WorkspaceJobs.CopyFromServer`) downloads through the desktop's session (`ISyncConnector`), never this PC's archive: one frames version with its aliases, each proxy (else the thumbnail standing in, `FileKind` thumb) hashed as it arrives and checked on disk, four at a time, resumable from final 5a's `copy:frame:fv:folder` checkpoint, the editor's current file never overwritten (other bytes under `ProxyName(id, sha)`), the space checked against the server's proxy sizes (the manifest has no file sizes), a cancelled first copy cleared like 5a's. | Copy through the proxy cache | The cache is the proxy editor's; the workspace owns its media. |
|
||||
| 2026-10-26 | Texts of a server's project are their key's `.Server` form when one exists (`WorkspaceText.ForHome`), else the key itself; the chip says *Server newer* and *Not on server*. | Format "the library" / "the server" into one text | Word order and articles differ by language; a missing form falls back to the library's text, never to a key. |
|
||||
| 2026-10-26 | A server's project renders what the server holds: before a render (`ProjectMenuViewModel.ReadyToRenderAsync`) unsaved or unsent work is offered to be saved and sent; Offline, Gone, Damaged or media removed hold the render. In step, the jobs name the version alone; out of step, the portable settings travel and only the project is recorded. An analysis's Auto values reaching Main at the server are taken by the next `projectChanged` (pushed) within 2 minutes, with Sync automatically. | Render the workspace's settings always | The server renders with its originals; only a version it holds can be named. |
|
||||
| 2026-10-26 | Edit opens a server's sequence as a workspace project when the server has the `projects` capability (`OpenServerWorkspaceAsync`), with final 5a's refusals (a copy this Chronos cannot read, a damaged or newer Main listed disabled, a workspace folder refused). The *sequence left the index* refusal applies only to projects of this PC's archive. An older server's sequences open with proxies as before. | Refuse every project whose sequence is not in the index | A server's sequence is never in this PC's index. |
|
||||
| 2026-10-26 | Unknown sequence, project or version is 404 `not_found` with details `sequence`, `project` or `version`; the push's refusals keep their own codes (`project_diverged`, `hash_mismatch`, `newer_format`, `invalid_version`, `too_large`). | Codes `sequence_not_found`, `project_not_found`, `version_not_found` | Every other endpoint answers 404 that way (§14.3); clients check one code. |
|
||||
| 2026-10-26 | A push answers `ProjectPushResultDto` (outcome, stored version, head) for 200, 201, 409 and 422, refusals with `code` and `message` too; `ChronosClient.PushProjectVersionAsync` returns it for those statuses without throwing. | An ApiError for refusals | A divergence needs the head; the stored version is what the workspace keeps; generic error readers still read code and message. |
|
||||
| 2026-10-26 | The server numbers a pushed version head + 1 and records the pushing account as its author, and the version's client name, else the token's. | Keep the author the client sent | On a server, versions are by accounts; the content hash covers only the settings; the workspace keeps the stored version, as with its archive. |
|
||||
| 2026-10-26 | Version pages use numbers: newest first below `before` (default 50), oldest first above `after` (default 100), 1–200, `more` read with one extra. | Opaque cursors | Numbers are contiguous, and a workspace pulls after its base's number. |
|
||||
| 2026-10-26 | Deleting a project needs Delete and the sequence's owner, the project's maker or an admin. Main is never deleted (409 `main_cannot_be_deleted`); the API can rename it, the panel cannot. | Delete alone; refuse renaming Main | Like deleting a sequence, while the maker may remove their own project on another's sequence; the engine allows the rename, and the panel shows Main in its language. |
|
||||
| 2026-10-26 | Main's head mirrored into the settings also sends `sequenceChanged` `settings`. | Only `projectChanged` | Older clients and desktop syncs read the settings and react to `sequenceChanged`. |
|
||||
| 2026-10-26 | `ProjectCatchUp`, a server background service, catches a sequence's projects up (`ProjectService.CatchUpAsync`) after a settings `PATCH`, an analysis's Auto values or a conversion's Replace: one sequence at a time, a sequence asked again while it waits caught up once, a busy lease tried again after 5 s, 30 s and 2 minutes, and only for sequences that already have a Main. It runs after an event and is no schedule (R10 is about recurring work). | Wait for the next project call | A workspace with Main checked out learns at once that its home moved; Main stays lazy, and no project files are written for sequences nobody opened as projects. |
|
||||
| 2026-10-26 | `projectChanged` goes to every signed-in subscriber of the event stream. | Filter by account | Sequences and projects are visible to every reader, as with `sequenceChanged`. |
|
||||
| 2026-10-26 | A render job's `projectVersionId` must be a version of a project of its sequence and names that project; `projectId` alone, without settings, is pinned to the project's head when the job is queued; a deleted project's versions still render. | Render the head at run time | The render records the version it rendered. |
|
||||
| 2026-10-26 | Render nodes get a version's settings (or the job's portable settings) already placed on the frames their claim lists, read as one frames version (`SequenceEndpoints.SnapshotOfAsync`); a version that is not the sequence's fails the job (`Errors.Render.ProjectVersion`). | Send portable settings for nodes to place | Older nodes keep working; the same placement as the server's own render. |
|
||||
| 2026-10-26 | The capability `projects` in `server/info`; the API stays version 1. | API version 2 | An additive change: old clients ignore it, new clients fall back on servers without it. |
|
||||
| 2026-10-26 | `GET …/projects/frames` answers every frame (`FrameDto`, index order) and the replaced tombstones as aliases (`RemovedPhotoDto`), as of one frames version, in one answer. | Pages with a frames-version guard | As the manifest does; placement needs one frames version. |
|
||||
| 2026-10-26 | The panel's Projects section: Main in the panel's language, with a mark only once renamed; Rename and Delete only for the others, Delete confirmed by name; no create, push or restore. | The desktop's project menu | R6: the panel manages, never edits. |
|
||||
| 2026-10-26 | `HomePhotos` is public. | Duplicate it in the server | The server builds a home's photos exactly as the archive does. |
|
||||
| 2026-10-26 | A server is a project home only while this PC is signed in to it (`SyncHost.ProjectHome`: one shared `ChronosClient` for the session's address and token, replaced at a new sign-in); otherwise its projects read Offline and still open from the workspace. Projects name the server by `SyncService.ServerKey` of the address they were made with. | Keep a token per server in each project file | One sign-in and one trust store; nothing new to protect; work never waits on a sign-in to be edited. |
|
||||
| 2026-10-26 | A project file of a server's sequence names an archive id made from the server's key (`ServerProjectHome.ArchiveIdOf`: a version 8 UUID from the SHA-256 of `chronos-server-archive:<key>`), with the server's name and no path. | Guid.Empty or a new random id | Stable per server, never one of this PC's archives, and older readers accept it. |
|
||||
| 2026-10-26 | The copy from a server downloads as the sync does (`SyncTransfers.DownloadFirstAsync`: the proxy, else the thumbnail) and checks a hash taken as the bytes arrive, then the file on disk; its downloads are not held on a metered connection. | A separate downloader; hold them like uploads | The server's manifest has no hash of a proxy; one code path with the sync; only uploads have the metered option (Server › Pause uploads on metered). |
|
||||
| 2026-10-26 | The editor of a server's workspace project runs analyses and renders as the server's jobs (`ServerJobs`, shared with `RemoteSequenceSource`). | This PC's engine | Renders run where the originals are (R8); one event-following code path. |
|
||||
| 2026-10-26 | An older server's rows offer *Open in workspace* disabled, with a tooltip giving the reason; *Open with proxies* stays. | Hide the action | It says why the workspace is not there. |
|
||||
| 2026-10-26 | `ServerProjectHome` reads the frames stamp from `GET …/projects/frames/stamp` (`ArchiveProjectHome.StampOfAsync` on the server), so a status downloads the server's frames only when the stamp moved. | Read the frames each time | Review 5b: every status of every server project downloaded the whole frame list. |
|
||||
| 2026-10-26 | A sequence without a folder (a server's sequence made before its first photo) keeps no projects: it lists none, `CreateAsync` and every other change refuse with `ProjectError.SequenceEmpty` (409 `sequence_empty`) before any lease or file, and the stored-version check answers false. The desktop says *This sequence has no photos yet.* | Make Main in the index only | Its folder is empty, so the sidecars and leases landed at the archive's root. |
|
||||
| 2026-10-26 | A settings PATCH on the server writes the sequence's `project.json` under the sequence lease first (`ArchiveService.EditSettingsAsync`, 20 s wait), then the index; the file is put back when the index does not take the edit. Busy, offline and moved answer 503 (`sequence_busy`, `archive_offline`, `folder_moved`), a file in use 409 `folder_in_use`. A PATCH of title or tags alone stays index-only. | Make Main's birth prefer the index | 5a's Data tests make `project.json` win on the desktop; the PATCH was the one writer that left it behind. |
|
||||
| 2026-10-26 | The push body limit is the version limit (64 MiB) plus 1 MiB; the client reads a 413 as `ProjectPushOutcomes.TooLarge` / `too_large`. Version pages stop once their settings add up to 4 Mi characters (always one version at least) and say `more`; `ServerProjectHome` pages on until it has what was asked. `summary=true` leaves the settings out (the admin panel). | One fixed page size | A page of 200 large versions was hundreds of MB. |
|
||||
| 2026-10-26 | Deleting a project as its maker needs the same account: same username, and an account made no later than the project. | Store the maker's id | No schema change; a name reused by a newer account no longer inherits the rights. |
|
||||
| 2026-10-26 | `projectChanged` is also told for a full rescan's reconcile and the read-only catch-up (compared around them, told after the lease), and a Main flip reads as `renamed`. | Tell only the API's own calls | Another PC's changes reached the workspaces only at their next read. |
|
||||
| 2026-10-26 | `SyncAgent` tells "changes may have been missed" only once the event stream is open again (`ISyncRemote.EventsAsync(connected, ct)`) and the refresh after it ran. | Tell at the loss | Told before the stream was back, a workspace re-read too early and missed changes made in between. |
|
||||
| 2026-10-26 | A server-side rename reaches the workspace copy: every pull and the `renamed` event write the home's name (and Main) into the bundle (`WorkspaceSync.FollowNameAsync`), errors ignored. | A new `IProjectHome.ProjectAsync` | `ListAsync` already answers; one call fewer to add to both homes. |
|
||||
| 2026-10-26 | `ServerProjectHome.HoldsAsync` reads the version file back (`GET …/versions/{id}?stored=true`, `ProjectService.StoredAsync`), false when the file is missing or damaged, or the project deleted. | Trust the index row | Pruning a local version needs proof the server's file holds it. |
|
||||
| 2026-10-26 | A copy from a server writes an empty `<file>.thumb` marker before a thumbnail taken for a missing proxy is moved into place; a resumed run reads it (and downloads the proxy when the server has it now); the commit removes the markers. | Download again every file of unknown kind | A resume would fetch every frame again. |
|
||||
| 2026-10-26 | An account without Edit is offered *Open with proxies* (read-only) on a server that keeps projects, never *Open in workspace*, and Edit checks nothing out for it; a copy the workspace already holds still opens, its pushes refused (403) as a refusal, not as Offline. | Check out read-only | A viewer's workspace copy could never be pushed. |
|
||||
| 2026-10-26 | The editor of a server's workspace project connects with the sign-in in use at each use (`WorkspaceServerHome(connect, session)`): a sign-in, sign-out or new sign-in drops the old connection and its jobs. `SyncHost` tells each session start and stop as `ProjectChanged(server, null)`. | Rebuild the editor | A project opened signed out could not render after signing in. |
|
||||
+12
-6
@@ -16,7 +16,7 @@ by its `windows` job once a Windows runner is registered (`WINDOWS_RUNNER`), and
|
||||
| 8 Release readiness | Release pipeline end to end (installers, portable and server zips, SHA256SUMS, release notes, optional signing, server image in the Gitea container registry, optional separate releases repository), update check with verified download, scrubbed diagnostics bundles (desktop and server), performance gates, 38 cultures (`en`, `it` and 36 machine translations with glossaries and independent reviews), RTL pass (`ar`, `he`: mirrored windows, left-to-right islands for media, charts, numbers and paths; any right-to-left culture added later follows), accessibility pass (names, live regions, keyboard paths for charts and the curve editor). The installer test (silent install of the packed installers, run, upgrade in place, uninstall: files, Add/Remove Programs, shortcuts, file type, user data kept, exit codes) runs in CI's `windows` job on a Windows runner. Pending: the interactive install on a real PC, Unraid template validation on a real server. |
|
||||
| 8.1 Owner review 1 | In progress (request, answers and plan: `docs/requests/2026-10-15-owner-review-1.md`). Phase 1 done: stalled thumbnail and proxy jobs no longer fail and stay Running (frame-counted progress, bounded time left, final state always written); the editor's cancelled decodes stay in their tasks (no debugger stops in `WicDecoderProvider.cs`); WIC decodes RAW only through the Raw Image Extension and never DNG; GoPro DNGs converted by Adobe software are DNGs, developed natively for videos, read through their embedded preview for analyses and previews, and reclassified in existing archives by the next light analysis. Phase 2 done: jobs run one at a time on the desktop and the server; Parallelism is how many photos the running job processes at once (thumbnail and proxy passes, tier probes, deep analysis, render decodes); pausing the running job starts the next; an optional priority queue by job kind (Settings › Rendering, admin panel › Settings › Jobs, `CHRONOS_PRIORITY_QUEUE`) pauses lower jobs and resumes them by themselves; `CHRONOS_PARALLELISM` replaces `CHRONOS_WORKERS`. Phase 3a done: the rail is 200 px and collapses to icons with ≡ or Ctrl+B (tooltips then name the sections, the choice saved at once); the admin panel's sidebar is 256 px and collapses the same way. Phase 3b done: the Sequence section is now Edit, one sequence at a time chosen in a picker inside the section (Change sequence, Ctrl+O; the sequence edited last selected first), and the editor's tabs are the steps of a guided, freely navigable path from a new Analysis step (every finding with the step that deals with it) to Export, each step showing where it stands, with Previous and Next. Next, after owner review 2 (the owner's order): phase 4, the visual crop locked to the output's proportions (R5) and mirroring, 90° rotations, straightening and colour filters (R6). |
|
||||
| 8.2 Chronos on Gitea | Done (request: `docs/requests/2026-10-23-chronos-gitea.md`): Titano renamed Chronos everywhere, translations' grammar included; repository, update check, links, issue forms and registry moved to the self-hosted Gitea; Gitea Actions CI, release, nightly image and performance workflows for the Linux runner, with the Windows programs cross-compiled and checked (`pe-check`); new `Chronos.Tools` commands `zip`, `gitea-release`, `postgres-ci`, `pe-check`. Pre-releases `v0.1.0-rc.1` and `v0.1.0-rc.2` (the update check builds its links from `ChronosReleasesUrl`, since Gitea's use its LAN ROOT_URL) published; `REGISTRY_TOKEN` is set and the `v0.1.0-rc.2` server image is in the registry. |
|
||||
| 8.3 Owner review 2 | In progress (request, answers and plan: `docs/requests/2026-10-26-owner-review-2.md`). Phase 1 done and released as `v0.1.0-rc.3` (one adversarial review round, 19 findings fixed; strings in all 38 languages): `:latest` follows the highest stable release, or the highest pre-release while none is stable (`Chronos.Tools release-channels`), `:nightly` stays the nightly build of `main` (R1); `CHRONOS_SPACE_PATH` and the Unraid template's *Array view* (`/mnt/user0/<share>` read-only at `/space`) make the admin panel show the array's free space, the cache apart as *Write volume*, the file system in the tooltip, and completing an upload checks the archive volume first (507, resumable) (R2); the Settings icon is a toothed gear and the admin panel docks Settings at the foot of its sidebar (R4); About is the last page of Settings on the desktop and the last group of Settings on the admin panel (R5); Import › Folder… › *Whole folder* imports a folder as one sequence per format, titled after the folder (R9). Phase 2 done and released as `v0.1.0-rc.4` (one adversarial review round, 35 findings fixed; strings in all 38 languages): scheduled jobs (R10) — schedules (migration 0007) with an in-house recurrence form, one scheduler per host claiming runs by compare-and-set with catch-up, and Jobs › Scheduled on the desktop and the admin panel (`/api/v1/schedules`, `scheduleChanged`); every timer that queued work is a visible system schedule (server: archive scan, upload clean-up every 6 h, index backup at 03:00, job history and audit log clean-ups; desktop: archive scan, daily index backup, housekeeping with cache trim), the archive still scanned at start; new Backup and Clean-up jobs, duplicates and orphans reports as jobs, one backup retention, the trash only reported; log settings (R11) — file and console levels, retention, file and total size limits, daily or hourly rotation, audit retention (the audit clean-up schedule's) and the diagnostics share in the admin panel's Settings › Logs (`CHRONOS_LOG_*`, `lockedBy`) and the desktop's Settings › Advanced; the server's files take Debug and Trace again, and logging never fails a job. Phase 3 done and released as `v0.1.0-rc.5` (one adversarial review round and two fix rounds, 40 findings fixed; strings in all 38 languages; Library, photo delete and restore and the web upload tried by hand): the admin panel manages and never edits (R6) — a Library page (facets filters, cards or list, keyboard selection, mass Analyse, Proxies, Thumbnails, Verify, Tags, Export CSV and Delete, 1,000 sequences a request), a sequence's page (inline title, tags, rating, notes, photo viewer, cover, downloads, photo delete) and the trash view (Restore, Empty… behind a dry run, the typed word and a fingerprint); photos deleted into `trash/photos` under crash-safe journals with tombstones in the sidecar and `frame_removals` (migration 0008), so sync and uploads never bring them back unless restored or uploaded again on purpose; trash kinds, restore reasons and the `EmptyTrash` job on the desktop's Trash… too (typed entry count); the panel's files revalidated (`no-cache`, ETag); upload from the panel (R3) — file picker or drop, no folders, a self-tested in-house SHA-256 in a module worker, Exif capture time, resumable chunks. Known limitations: a never-hashed photo whose file was already missing is deleted without a tombstone; an unhashed server frame of a photo deleted on a PC stays *missing here* until the server verifies it; `jobState` carries no kind, so panel pages refresh after any job. Phase 4a done and released as `v0.1.0-rc.6` (one adversarial review round and six fix rounds; strings in all 38 languages): Reorganize after import (R7) on the desktop (Archive manager, Library, the toast after Settings › Archive templates change; it replaces Rename… and Move…) and the admin panel (Library, the *Saved* toast of Archive) — folder, file and title templates applied to filed sequences behind a dry run that lists every change, the photos that keep their names and why (in place, never verified, missing) and the sequences that stay whole (unreadable sidecar), applied by the `move` job of exactly the confirmed plan (fingerprint, `POST /api/v1/archive/reorganize`, plans kept a few minutes on the server), which holds the rest when paused, cancelled or failed (also while the archive is offline), lets a sequence still receiving photos keep its file names and takes along a sequence left as it was inside a folder that moves; files renamed in two phases under `.chronos/rename-files.json`, completed after a crash by the next writer; the index, frames and exports follow a moved folder in one transaction, here and at another index's next scan, and writers never create a folder a Reorganize left nor write into one another sequence took; import, upload and Reorganize name photos by one rule (the sequence's camera and lens), and templates follow one set of rules everLine truncated
|
||||
| 8.3 Owner review 2 | In progress (request, answers and plan: `docs/requests/2026-10-26-owner-review-2.md`). Phase 1 done and released as `v0.1.0-rc.3` (one adversarial review round, 19 findings fixed; strings in all 38 languages): `:latest` follows the highest stable release, or the highest pre-release while none is stable (`Chronos.Tools release-channels`), `:nightly` stays the nightly build of `main` (R1); `CHRONOS_SPACE_PATH` and the Unraid template's *Array view* (`/mnt/user0/<share>` read-only at `/space`) make the admin panel show the array's free space, the cache apart as *Write volume*, the file system in the tooltip, and completing an upload checks the archive volume first (507, resumable) (R2); the Settings icon is a toothed gear and the admin panel docks Settings at the foot of its sidebar (R4); About is the last page of Settings on the desktop and the last group of Settings on the admin panel (R5); Import › Folder… › *Whole folder* imports a folder as one sequence per format, titled after the folder (R9). Phase 2 done and released as `v0.1.0-rc.4` (one adversarial review round, 35 findings fixed; strings in all 38 languages): scheduled jobs (R10) — schedules (migration 0007) with an in-house recurrence form, one scheduler per host claiming runs by compare-and-set with catch-up, and Jobs › Scheduled on the desktop and the admin panel (`/api/v1/schedules`, `scheduleChanged`); every timer that queued work is a visible system schedule (server: archive scan, upload clean-up every 6 h, index backup at 03:00, job history and audit log clean-ups; desktop: archive scan, daily index backup, housekeeping with cache trim), the archive still scanned at start; new Backup and Clean-up jobs, duplicates and orphans reports as jobs, one backup retention, the trash only reported; log settings (R11) — file and console levels, retention, file and total size limits, daily or hourly rotation, audit retention (the audit clean-up schedule's) and the diagnostics share in the admin panel's Settings › Logs (`CHRONOS_LOG_*`, `lockedBy`) and the desktop's Settings › Advanced; the server's files take Debug and Trace again, and logging never fails a job. Phase 3 done and released as `v0.1.0-rc.5` (one adversarial review round and two fix rounds, 40 findings fixed; strings in all 38 languages; Library, photo delete and restore and the web upload tried by hand): the admin panel manages and never edits (R6) — a Library page (facets filters, cards or list, keyboard selection, mass Analyse, Proxies, Thumbnails, Verify, Tags, Export CSV and Delete, 1,000 sequences a request), a sequence's page (inline title, tags, rating, notes, photo viewer, cover, downloads, photo delete) and the trash view (Restore, Empty… behind a dry run, the typed word and a fingerprint); photos deleted into `trash/photos` under crash-safe journals with tombstones in the sidecar and `frame_removals` (migration 0008), so sync and uploads never bring them back unless restored or uploaded again on purpose; trash kinds, restore reasons and the `EmptyTrash` job on the desktop's Trash… too (typed entry count); the panel's files revalidated (`no-cache`, ETag); upload from the panel (R3) — file picker or drop, no folders, a self-tested in-house SHA-256 in a module worker, Exif capture time, resumable chunks. Known limitations: a never-hashed photo whose file was already missing is deleted without a tombstone; an unhashed server frame of a photo deleted on a PC stays *missing here* until the server verifies it; `jobState` carries no kind, so panel pages refresh after any job. Phase 4a done and released as `v0.1.0-rc.6` (one adversarial review round and six fix rounds; strings in all 38 languages): Reorganize after import (R7) on the desktop (Archive manager, Library, the toast after Settings › Archive templates change; it replaces Rename… and Move…) and the admin panel (Library, the *Saved* toast of Archive) — folder, file and title templates applied to filed sequences behind a dry run that lists every change, the photos that keep their names and why (in place, never verified, missing) and the sequences that stay whole (unreadable sidecar), applied by the `move` job of exactly the confirmed plan (fingerprint, `POST /api/v1/archive/reorganize`, plans kept a few minutes on the server), which holds the rest when paused, cancelled or failed (also while the archive is offline), lets a sequence still receiving photos keep its file names and takes along a sequence left as it was inside a folder that moves; files renamed in two phases under `.chronos/rename-files.json`, completed after a crash by the next writer; the index, frames and exports follow a moved folder in one transaction, here and at another index's next scan, and writers never create a folder a Reorganize left nor write into one another sequence took; import, upload and Reorganize name photos by one rule (the sequence's camera and lens), and templates follow one set of rules everLine truncated
|
||||
| 9 Monetization | Not started: requires explicit approval (§22). |
|
||||
|
||||
## Verification (2026-10-12)
|
||||
@@ -101,6 +101,12 @@ src/Chronos.App/bin/Release/net10.0-windows/Chronos.exe --capture out/screenshot
|
||||
Ctrl+O lists the project in the picker's *Workspace* group. The title's ▾ › *History…* › *Compare* or *Restore*;
|
||||
▾ › *Remove local copy…* shows its plan. Two workspace folders on one archive (Settings › Workspace › *Change…*)
|
||||
stand in for two PCs: change the same setting in both and *Sync* to see the conflict dialog.
|
||||
- Server home: sign in on Server to a server of this release; a server-only row offers *Open in workspace* (an older
|
||||
server shows it disabled). Choose a project (New, with a name): a *Workspace copy* job downloads the proxies and the
|
||||
editor opens. Edit, Ctrl+S, Enter: the chip says *In sync*, and the admin panel's sequence page lists the version
|
||||
under *Projects*. Rename the project there: the editor's project button takes the new name. Change a setting of
|
||||
Main from another PC (or an older Chronos) on the server while Main is open here: the chip says *Server newer*;
|
||||
*Sync* takes it. *Render* offers *Send and render* while changes are not sent, then renders on the server.
|
||||
- Project files: Export › *Save project file* writes a `.chronos` file; opening it (double-click or `Chronos.exe <file>`)
|
||||
opens the sequence with those settings in the running Chronos, given to its Main project in the workspace.
|
||||
- Notifications: minimise Chronos and insert a card or finish a job: a Windows notification appears; Ctrl+1…6 and
|
||||
@@ -114,11 +120,11 @@ src/Chronos.App/bin/Release/net10.0-windows/Chronos.exe --capture out/screenshot
|
||||
Owner reviews, in the owner's order (owner review 2 first, then the rest of owner review 1); each phase ends with a
|
||||
release (owner review 2, R12):
|
||||
|
||||
1. Owner review 2, phase 5a: translate its 241 new keys into the 36 other languages, then release `v0.1.0-rc.8`
|
||||
(the PR green on Gitea Actions, squash-merge, tag, the Docker image and the Windows programs) and update the
|
||||
memory notes.
|
||||
2. Owner review 2, phase 5b: R8 server home (the projects API under `/sequences/{id}/projects`, `projectChanged`, the
|
||||
server's `IProjectHome`, workspace copies from the server, Open in workspace on the Server screen).
|
||||
1. Owner review 3, phase 1: release the ports fix as `v0.1.0-rc.9`.
|
||||
2. Owner review 2, phase 5b: settle the Server screen's row buttons and recapture the `server-*` baselines (and fix
|
||||
the TEMP path the capture shows), translate the new keys into the 36 other languages, then release
|
||||
`v0.1.0-rc.10` (the PR green on Gitea Actions, squash-merge, tag, the Docker image and the Windows programs) and
|
||||
update the memory notes.
|
||||
3. Owner review 2, phase 5c: R8 originals, local render (`WorkspaceRender`), Remove local copy's clean-up and the
|
||||
workspace's trash, the size limit, moving the workspace folder, the rest of Settings › Workspace.
|
||||
4. Owner review 1, phase 4: R5 visual crop locked to the output's proportions, R6 mirroring, 90° rotations,
|
||||
|
||||
@@ -75,7 +75,7 @@
|
||||
| 4a | R7 Reorganize after import | done 2026-10-27, released as `v0.1.0-rc.6` (one adversarial review round and six fix rounds; strings in all 38 languages): BRIEF §5, §7, §7.1, §12.2, §12.5, §12.8, §13, §14.3, §14.5, §14.8, §24; 25 DECISIONS rows dated 2026-10-26 (R7 one naming rule `FrameNaming` for import, upload and Reorganize; what Reorganize renames and what stays whole; unique names in index order and XMP companions; the two-phase file journal; step order and checks under the leases; the fingerprint pinning file renames by digest; sequences still receiving photos; a sequence left inside a moving folder taken along; Reorganize as the `move` job with held plans; the whole-plan tally and errors; `sequenceChanged` `reorganized` and the editor reload; exports rebased with their folder; the rows of a sequence that took the old folder never follow; writers under the lease and render filing's 503; a folder another sequence holds refused by every writer; proxy lease batches; case-only and stable folders; template rules; rules held only to templates given anew; the server's plan cache; the reorganize API; panel selection and dialog; the desktop dialog and the Settings toast; render leftovers removed only where the sequence is; originals restored only where the sequence is), three earlier rows marked superseded; CHANGELOG [0.1.0-rc.6] with the template upgrade note and the known limitations; STATUS 8.3 | `7e4a3b48` |
|
||||
| 4b | R7 mass conversion | done 2026-11-02, released as `v0.1.0-rc.7` (one adversarial review round, 42 findings, and two fix rounds; strings in all 38 languages): BRIEF §5, §7, §8.1, §8.3, §8.7, §9, §12.2, §12.4, §12.5, §13, §14.3, §14.4, §14.5, §14.8, §14.9, §24; 26 DECISIONS rows dated 2026-10-26 (R7 conversion after import, import still byte for byte; Replace or New sequence at every run, never remembered; targets and the scene-referred archival DNG; the conversion's decoder order, managed first and no 16-bit file from an 8-bit RAW development; the TIFF reader's refusals; colour profiles carried, converted or refused; the converted files' Exif; a dry run that probes what it promises; exactly the confirmed photos, by digest and ids; the two-stage, resumable job; the purge of staging and journals; free space measured where the conversion writes; no conversion of the same sequences twice; New sequence holding the converted copies alone, saying what it lacks; the Replace swap; the replace journal decided by content; Undo by the job's own entries; replaced entries weighed against the archive on disk; every last copy named before the typed confirmation; sync aliases as equivalence classes; link by content, proxies and downloads following them; the ingest taking a replaced original as present; the plan cache shared with Reorganize; the convert API; the `convert` job kind; failure sentences by cause), four earlier rows marked superseded in part; CHANGELOG [0.1.0-rc.7] with the upgrade note and the known limitations; STATUS 8.3 | `efa87f68` |
|
||||
| 5a | R8 workspace and projects with a local home (migration 0009) | done 2026-11-03, released as `v0.1.0-rc.8` on 2026-11-04 (one adversarial review round, 55 findings, and five fix rounds; strings in en and it, the 36 other languages still to translate): BRIEF §4.4, §5, §7, §12.2, §12.3, §12.6, §12.8, §14.5, §14.6, §24; 46 DECISIONS rows dated 2026-11-03 (R8 projects and versions in the index by migration 0009; the sidecars as the truth; the portable form with positions parked by photo and canonical text; placing by photo; unknown members kept; a newer settings format read only; project file format 2; the 64 MiB limits; Main mirroring the settings and `project.json`; the Main catch-up merge; a mirror never written over settings it has not taken in; deletion from the trash read first, late versions moved beside it; lost and behind records; one Main; push rules; `IProjectHome`; the workspace folder and its write order; versions set aside and pruned; conflicts and Save both naming; media learning names; the frames stamp; Gone and Damaged states; newer and damaged copies; Edit opening workspace projects; editor saves; sync; Kept versions; Remove local copy; Delete project; the workspace copy job and its cancel clean-up; renders with project and version; `.chronos` files; the picker; Settings › Workspace; texts; `IWorkspaceUi`; leases), five earlier rows marked superseded in part; CHANGELOG [0.1.0-rc.8] with the migration 0009 upgrade note and the known limitations; STATUS 8.3 | `9b24cf74` |
|
||||
| 5b | R8 server home | todo | |
|
||||
| 5b | R8 server home | done 2026-11-04, to be released as `v0.1.0-rc.10` (one adversarial review round, 21 findings, 19 fixed; strings in en and it, the 36 other languages still to translate; the Server screen's row buttons and the TEMP path in 8 screenshot baselines still open): BRIEF §4.4, §7, §12.2, §12.3, §12.7, §14.3, §14.5, §14.7, §14.8, §24; 40 DECISIONS rows dated 2026-10-26 (R8 the server home on the archive's `ProjectService`, errors mapped to Offline, refusals and API errors; a deleted project's head 404; `too_large` and `projects_unreadable`; change sets told after the lease; pruning by read-back; the copy from a server; texts of the server; renders of what the server holds; Edit opening server sequences; 404 `not_found` with details; push results; the pushing account as author; numbered version pages; delete rights and Main's rename; `sequenceChanged` with Main's mirror; `ProjectCatchUp`; events to every subscriber; render jobs and nodes of a project version; the `projects` capability; the frames answer; the panel's Projects section; `HomePhotos` public; the sign-in as the only way to a server home; the server's archive id; the copy's download and metered rule; `ServerJobs`; the older server's disabled action; review fixes: the frames stamp, sequences without photos, the settings `PATCH` under the lease, push and page size limits, the maker's account, rescans and read-only catch-ups told, missed changes told once the stream is back, server renames followed, the stored check, the `.thumb` marker, viewers with proxies, the editor following the sign-in), three earlier rows marked superseded in part; CHANGELOG [Unreleased] with the upgrade note and the known limitations; STATUS 8.3 | |
|
||||
| 5c | R8 originals, local render, clean-up, Workspace settings | todo | |
|
||||
|
||||
Each phase updates BRIEF (amended paragraphs), DECISIONS, CHANGELOG, STATUS and this file, and ends with a release
|
||||
|
||||
Reference in new issue
Block a user