docs: owner review 6 request, brief amendments and decisions for matches (v1.2.0)
Owner review 6 asks Chronos to recognise the same time-lapse on a server and on this PC, show the differences and let the user keep the two apart or integrate and sync them. The request file keeps the owner's words, the reading R1-R8, the eight answers and the delivery plan; the brief now describes matches, the Compare dialog, Integrate, the merge of two local sequences, the automatic photos of integrated pairs, the photo lookup and uploads into a target, and amends 14.5 so other projects cross only through Integrate or a merge. DECISIONS records the design choices and those taken while building it; the changelog, status, architecture and design notes follow, and the version moves to 1.2.0. Refs #73 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
9657c1711d
commit
59235e7c25
8 files changed
+443
-18
No files matched your search
@@ -1,7 +1,7 @@
|
||||
<Project>
|
||||
<PropertyGroup>
|
||||
<RepoRoot>$(MSBuildThisFileDirectory)</RepoRoot>
|
||||
<ChronosVersion Condition="'$(ChronosVersion)' == ''">1.1.1</ChronosVersion>
|
||||
<ChronosVersion Condition="'$(ChronosVersion)' == ''">1.2.0</ChronosVersion>
|
||||
<Version>$(ChronosVersion)</Version>
|
||||
<AssemblyVersion>$([System.Text.RegularExpressions.Regex]::Match($(ChronosVersion), '^\d+\.\d+\.\d+').Value).0</AssemblyVersion>
|
||||
<FileVersion>$(AssemblyVersion)</FileVersion>
|
||||
|
||||
+11
-8
@@ -59,15 +59,16 @@ Dependencies point one way: `Core` ← `Core.Windows`, `Data`, `Protocol` ← `S
|
||||
| `Sqlite`, `Postgres` | SQLite P/Invoke binding (winsqlite3 / libsqlite3), in-house PostgreSQL wire protocol v3 client with pool and LISTEN |
|
||||
| `Migrations/{sqlite,postgres}/NNNN_name.sql` | Embedded, applied in one transaction at open (`MigrationRunner`) |
|
||||
| `Repositories` | `ChronosDatabase` facade: archives, sequences, frames, tags, renders, jobs, cards, users, tokens, uploads, render nodes, settings, audit, schedules (`ScheduleRepository`: system rows seeded without overwriting edits and never deleted, the compare-and-set claim of a run), tombstones of removed photos (`FrameRemovalRepository`, `frame_removals`, written from the sidecar's `removed` list), `SequenceRepository.GetStampAsync` (a digest of what a Reorganize plans from in the index) and `GetConvertStampAsync` (with what a conversion plans from: its photos' count, sizes, formats, pixel sizes and the flags that decide), `JobRepository.ListPendingTargetsAsync` (the targets of pending jobs of a kind, also of those created before a time), `RenderRepository.RebaseFolderAsync` (the export paths that follow a moved folder), `ListPageAsync` (the videos library's keyset pages, filters and orders; a kindless still recognised in SQL by its image codec, fps 0 and duration 0) and `SetSha256Async` (a lazy hash); `RenderCopyRepository` (`render_copies`, migration 0010: the verified copies in a videos folder, no foreign key to `renders`); projects and their versions (`ProjectRepository`, `projects`, `project_versions`: rows derived from the projects' sidecars, a head advanced by compare-and-set, Main's last mirror); `JobRepository.ListPendingAsync` (the queued, running and paused jobs of a kind and target, full rows); `FrameRepository.CountNamedAsync` (hashed frames and a checksum of their hashes, for a home's frames stamp); `DatabaseBackups` (`VACUUM INTO` copies of an SQLite index into `backups` next to it, every copy keeping as many as the backup schedules keep (`KeptAsync`), the newest copy that seeds the `index-backup` schedule (`Newest`, `SystemSchedule.LastDone`), restore staged for the next start and carried out before the index opens, so it also recovers one that no longer opens) |
|
||||
| `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). Owner review 5, #65: `JobContext.ReportAsync(done, total, JobDetail)`, `CheckpointAsync(…, detail)` and `ReportItemAsync` (item counts of the current detail with no allocation); publishing throttled to one report per `JobEngineOptions.ProgressInterval` (500 ms) per job with bypass for the first report, a step change and a completed count; `JobWire` maps the detail (`DetailJson`, `ParseDetailJson` never throws); `jobs.progress_detail` (migration 0011) |
|
||||
| `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). Owner review 5, #65: `JobContext.ReportAsync(done, total, JobDetail)`, `CheckpointAsync(…, detail)` and `ReportItemAsync` (item counts of the current detail with no allocation); publishing throttled to one report per `JobEngineOptions.ProgressInterval` (500 ms) per job with bypass for the first report, a step change and a completed count; `JobWire` maps the detail (`DetailJson`, `ParseDetailJson` never throws); `jobs.progress_detail` (migration 0011). Owner review 6, #73: a `JobPriority.Background` job never makes a running job yield; kinds `Integrate` (25) and `MergeSequences` (26), high by default; steps `Details`, `Projects` and `Trash` |
|
||||
| `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; `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
|
||||
| `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` (a newer format refused as `Errors.Render.NewerSettings`), `ProjectBundles` (a `.chronos` file for a sequence, and the sequence a file names), `ProcessingJobs` (`Routed`: a render job sized from its resolved preset box through `RenderSize` and given its `RequiredSettingsFormat`, read from the job's own export and never below the stored settings' format; `RequiredFormat` over a batch's presets, used by the desktop's gates; `BatchExport` carrying the playback; `Still`: a still job, `StillFrame` and `StillPhoto`, format 3), `RenderNodeClient` (registers the node's settings format), job handlers (`RenderJobHandler` hashes each single-file output and records its kind, stills included) |
|
||||
| `Videos` | Owner review 1, R9: `IVideoLibrary` (`ArchiveService.Videos`; the server's and the desktop's one library: list and get as `VideoItem` with state and copies, `PlanDeleteAsync` and `DeleteAsync` by fingerprint, `RestoreAsync` by trash entry, `CopiesAsync`, `CopyJob`, `FolderProblem`; `VideoQuery`, `VideoErrors` and `VideoLibraryException`, `VideoTrashNames`), `VideoLibrary` (`ProtectedFolders`: the host's folders a videos folder may not be in, the workspace on the desktop, the data folder on the server; `RecoverAsync` at open), `VideoTrash` (`.chronos/trash/videos/`: delete under the sequence's lease with a `.pending` record journal, a rename or a verified cross-volume copy, the row removed and `rendered_count` recounted, `.leftover` markers for a source a copy could not remove; restore after a re-hash under a free name, same render id; entries listed through `SequenceTrash` as `TrashKind.Videos`, titled by their sequence), `VideoCopyJobHandler` (`video-copy`, 24: free space for every render first, `.incoming-<id>.part`, hash, rename without overwrite, `render_copies`; a server's render downloaded on the desktop; checkpoint `done:<n>`), `VideosFolder` (validation, free space, " (2)" collision names, part-file names) |
|
||||
| `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; `OneFraming`: a turn or mirror on one side and a framing edit on the other are one conflict at the orientation member), `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) |
|
||||
| `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; `OneFraming`: a turn or mirror on one side and a framing edit on the other are one conflict at the orientation member), `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). Owner review 6, #73: `ProjectTransplant` (`IProjectCopier`: a project and its history copied to another home for an Integrate or a merge, an intent journaled before the copy is made, each pushed version verified against its content hash, a copy someone else changed left alone; `FreeName` "name (PC)", "(2)"… within the name limit; `TransplantFormatException` for a newer settings format) |
|
||||
| `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); phase 5c: `WorkspaceProject` gains `media/originals/<frame id>-<sha8><ext>` (`OriginalName`), the ledger `exports/renders.json` (`WorkspaceRenders`, `WorkspaceRenderEntry`; `ContainedExportFile` keeps every ledger path inside `exports/`), `media.json` format 2 while it holds originals or was cleaned (`WorkspaceMedia.Cleaned`) and the project file format 3 while its media are Originals; `WorkspaceOriginals` (Proxies only's plan and apply, and `ClearOriginals`: every file of `media/originals` hashed and deleted only when the home's frames hold its SHA-256, the rest moved to the trash), `WorkspaceTrash` and `WorkspaceTrashBuilder` (`<workspace>/.trash`: entries `<project id>-<ticks>` filled under `.incoming-<id>-<ticks>` and renamed when whole, listed with a fingerprint of every file's path, size and time, emptied only by a plan that still matches), `WorkspaceCleaner` (the clean-up of media of projects in step with their home: Clean after, Size limit, the reasons a project is kept in `WorkspaceKeep`, `UnsentRenders`), `WorkspaceMover` (survey, plan fingerprint, the journal `<from>/.move.json` with stages Moving and Switched, rename on one volume or copy and hash-verify across volumes, resume, abandon, clear after the switch), `WorkspaceJobRoots` (internal, in `WorkspaceJobs.cs`: the folder a copy, render or send works in, the one that holds its project now, refused while a move has not switched) and the job parameters `WorkspaceRenderParameters`, `WorkspaceSendParameters`, `WorkspaceMoveParameters` in `WorkspaceJson`. Owner review 5, #66: `WorkspaceHomes` (the parent `workspace.json` format 2, layout "homes": `local` and `servers/<folder>`, each an ordinary store with `server.json`, `ServerHomeRecord`; `StoreFor(home)`, `All()`), `WorkspaceStore` refusing the homes layout and a read-only legacy view, `WorkspaceJobRoots` searching every home, `WorkspaceJobOptions.SameServer`/`IsSameServer` (aliases, used by the copy and send handlers' home checks), `WorkspaceMover` and `WorkspaceCleaner` over every home |
|
||||
| `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`). Owner review 5, #66: `ServerIdentity` (`KnownServerKey`; `Key`, `Canonical`, `Same`, `KeysOf`, `FolderName`, `With`), `SyncOptions.ServersDirectory` and `Identity`, `ProxyCache` per server with alias and 1.0 fallback reads, `SyncService.RekeyAsync`/`SyncLinkStore.RekeyAsync` |
|
||||
| `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`). Owner review 5, #66: `ServerIdentity` (`KnownServerKey`; `Key`, `Canonical`, `Same`, `KeysOf`, `FolderName`, `With`), `SyncOptions.ServersDirectory` and `Identity`, `ProxyCache` per server with alias and 1.0 fallback reads, `SyncService.RekeyAsync`/`SyncLinkStore.RekeyAsync`. Owner review 6, #73: `CopyComparer` (`CopyComparison.cs`, pure, O(n log n): every photo of two copies classed Same, Converted, SameUnhashed, DeletedHere/There, Differs, Versions, OnlyHere/There, and the score; records in `CopyComparisonModel.cs`); `SyncService` no longer links by content (`MatchByContentAsync` removed): `RefreshAsync` runs `Finder.FindServerAsync` after releasing its gate and raises `CopiesFound`; `UnlinkAsync`, the 404 marks, `ApplyAgreedAsync` (agreed details, server first), `EnqueueUploadAsync` with a priority; `SyncTransfers.SendPhotosAsync`/`FetchPhotosAsync` (only the photos asked for, never creating or retargeting a server sequence, `RemoteGoneException`) and linked uploads with `intoTarget`; `SyncAgent` queues an integrated pair's automatic photos (Background) and counts `PhotoFailures`, `PhotosNotSent` after `NotSentAfter` (3); `ISyncRemote` gains `LookupPhotosAsync`, `UploadFileIntoAsync`, `DeleteFramesAsync` and a capabilities read cached per remote |
|
||||
| `Copies` | Owner review 6, #73 (namespace `Chronos.Data.Copies`; matches: the same time-lapse on a server and on this PC, or twice on this PC). Contracts: `CopyModel` (`FoundCopy`, `CopyKind`, `CopyState`, `CopyEvidence`, `CopyScore`, `CopyLinking`, `CopyPhotoPolicy`, `CopyProjects`), `CopyReviewModel` (what the Compare dialog shows), `CopyPlans` (`IntegratePlan`, `MergePlan`, `CopyBlock`, `CopyPlanContext`, the trash plans), `CopyJobParameters`, `ICopyEngine` (the App's one entry). `FoundCopyStore` (`found_copies` and `copy_probes`, migration 0012: upserts that never touch the answer, state by compare-and-set, an Integrating row whose job failed or is gone read as its previous state, `EnsureLinkedAsync`, the 404 marks, `ReleaseAsync`, the merge's links stage `MoveToKeptAsync`, the local overlap queries, the probes; re-keyed with the links by `SyncLinkStore.RekeyAsync`). `CopyRules` (pure: `IsCopy`, `Decide` by the *Link matches* setting, `SameOriginals` (1.1's rule), `AsksAgain`, fingerprints, hints, the probe sample). `CopyPayload` (pure: details as portable lines, `Merge` of the chosen sides into one payload, `ExcludeVersions`). `CopySides` (both sides from the index and a server; `HeldElsewhereAsync`, the last-copy check across every archive; `VersionsAsync`, second versions). `CopyFinder` (`FindServerAsync` after each refresh: probes, `POST /photos/lookup` in batches, manifest comparison, at most 50 a refresh (20 on an older server), `Decide`; `FindLocalAsync`; `ResetProbesAsync`). `CopyReviewBuilder` (facts, full comparison, detail lines, projects, renders, capabilities with their blocks). `IntegratePlanner` (the Integrate dry run and fingerprint), `IntegrateJobHandler` and `IntegrateJournal` (`integrate`, 25: journal `.chronos/journal/integrate-<job>.json`; link, photos both ways, trash after the winner's hash, details through `SyncService.ApplyAgreedAsync`, projects through `ProjectTransplant`), `CopyJobs` (handler and queuing, pair to Integrating by compare-and-set). `CopyEngine` (`ICopyEngine` composed: list, find, compare, plan and queue Integrate and merges, keep apart, ask again, link, unlink, keep here, trash here and there with a re-read of the other side, twins; optional dependencies keep App types out). `UploadAllRule` (pure: what *Upload all local* skips and why). Owned by the copies code; `Sync`, `Archiving` and `Projects` call into it only through `FoundCopyStore` and `CopyFinder` |
|
||||
| `Homes` | Owner review 5, #66: `HomeLayoutMigration` (`PlanAsync`, `ApplyAsync`: the 1.0 workspace and cache sorted into homes by same-folder renames checked by inventory, deferrals for leased projects, an offline workspace and an unfinished move; `RekeyAsync`: an address home renamed to the server id at sign-in), `HomeLayoutJournal` (the journal in the data folder that resumes after a crash) |
|
||||
|
||||
### 2.3 Chronos.App areas
|
||||
@@ -82,10 +83,10 @@ Dependencies point one way: `Core` ← `Core.Windows`, `Data`, `Protocol` ← `S
|
||||
| `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`; phase 5c partials: `WorkspaceHost.Media` (Copy originals, Proxies only), `.Render` (local renders, Send again), `.Cleanup` (usage, the clean-up after each copy and by schedule, the trash's plan and Empty, the removal's unsent renders and originals) and `.Move` (move plan and job, `IsMoving` gate, `MoveEnded`, the unfinished move)), `WorkspaceFolderChange` (Settings › Workspace › Change…, Move… and Resume, 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). Owner review 5, #66: `WorkspaceHost.Homes`, `Find`, `SyncOf`/`SyncFor` (one sync per store), `SameServer`, `Identity`, `Reopen` (the `Store` and `Sync` properties are gone) |
|
||||
| `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 (`UploadHold`: uploads, downloads and the workspace's server copies and sends), 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`. Owner review 5: `SyncHost.Identity`, `KeyOf`, `LastServer`, `KnownServersChanged`, `IdentityClash`, `OriginalsArchiveAsync`/`OriginalsForDownloadAsync`/`OriginalsArchivesAsync` and the re-key in `SwitchAsync` (#66); `ServerJobsApi` (`IServerJobsApi`) and `ServerJobsViewModel`/`ServerJobsView`, the connected server's running and paused jobs (#65); `LibraryShare` (`ShareState`, `ShareClient`, `ShareUploadsStep`: this PC's library shared on the LAN through `Chronos.Server`'s `HostedServer`, #67) and `ConnectFlow` refusing the own share (`ConnectError.OwnLibrary`) |
|
||||
| `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`, `workspace-cleanup`; `CacheTrimStep`, `WorkspaceCleanStep` and `WorkspaceTrashStep`, the host's clean-up steps; `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. Owner review 5: `JobText.Status`/`RowStatus`/`RowStatusToolTip` (the status line of a job's detail, `BarStatusLength` 60) and `JobEntry.Detail` (#65); `Settings/HomeRows` (`HomeFolderRow`, `KnownServerRow`, #66) and `Settings/ShareSettingsRows` (#67) |
|
||||
| `Server` | `ServerSession`, `ConnectFlow` (trust on first use), `SyncHost` (sync engine, agent, metered hold (`UploadHold`: uploads, downloads and the workspace's server copies and sends), 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`. Owner review 5: `SyncHost.Identity`, `KeyOf`, `LastServer`, `KnownServersChanged`, `IdentityClash`, `OriginalsArchiveAsync`/`OriginalsForDownloadAsync`/`OriginalsArchivesAsync` and the re-key in `SwitchAsync` (#66); `ServerJobsApi` (`IServerJobsApi`) and `ServerJobsViewModel`/`ServerJobsView`, the connected server's running and paused jobs (#65); `LibraryShare` (`ShareState`, `ShareClient`, `ShareUploadsStep`: this PC's library shared on the LAN through `Chronos.Server`'s `HostedServer`, #67) and `ConnectFlow` refusing the own share (`ConnectError.OwnLibrary`). Owner review 6, #73: `Server/Copies` (`CopyListViewModel` and `CopyRow`: Server › Matches, its chip, actions, toasts and the Library statuses; `CopyText`: the pure words, glyphs and actions of a pair; `CopyDialogViewModel` with `CopyPhotoRow`, `CopyDetailRow`, `CopyProjectRow`, `CopyPlanLine` and `CopyDialogs.xaml`: the in-window Compare/Integrate and merge dialog hosted by `ServerView`; `CopyScenes`: the capture and test scenes), `CopyWatch` (local detection after the index opens and after jobs that change photos), `WorkspaceCopyGuard` (`IWorkspaceGuard` over `WorkspaceHost.HasUnsentWorkAsync`), `SyncHost.Copies` (the `CopyEngine`), `UploadHold` holding `Integrate`, `SyncTableViewModel` applying `UploadAllRule` |
|
||||
| `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`, `workspace-cleanup`; `CacheTrimStep`, `WorkspaceCleanStep` and `WorkspaceTrashStep`, the host's clean-up steps; `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. Owner review 5: `JobText.Status`/`RowStatus`/`RowStatusToolTip` (the status line of a job's detail, `BarStatusLength` 60) and `JobEntry.Detail` (#65); `Settings/HomeRows` (`HomeFolderRow`, `KnownServerRow`, #66) and `Settings/ShareSettingsRows` (#67). Owner review 6, #73: `Settings/CopySettingsRows` (Link matches, Integrate photos, Integrate projects; `SettingsOption.ToolTip` per option); Jobs opens Server › Matches for an Integrate and the kept sequence for a merge |
|
||||
| `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. Owner review 5: `AppSettings.KnownServers` and `Share`, `AppServices.SortHomesAsync` with `HomeLayout`/`HomeLayoutError`, `CacheStore.ServersFolder`/`ServerFolder`, `AppServices.Share` |
|
||||
| `DesignTime` | `SampleData`: the archive, jobs and server the screenshots and smoke tests run on, dated from the fixed `SampleData.Now`; `SampleJobDetails.Apply` (the sample jobs' details), `SampleServerJobs` (the server jobs capture) |
|
||||
| `DesignTime` | `SampleData`: the archive, jobs and server the screenshots and smoke tests run on, dated from the fixed `SampleData.Now`; `SampleJobDetails.Apply` (the sample jobs' details), `SampleServerJobs` (the server jobs capture); `SampleCopies` (`SampleCopyEngine`, the sample matches in every state; owner review 6, #73) |
|
||||
|
||||
### 2.4 Chronos.Ui and Chronos.Server
|
||||
|
||||
@@ -98,7 +99,7 @@ Dependencies point one way: `Core` ← `Core.Windows`, `Data`, `Protocol` ← `S
|
||||
| `Ui/Visuals` | `DrawingElement` (hover readout, item keyboard and activation) and its charts (`BarChart`, `SeriesChart`, `StackedBar`, `HeatmapStrip`, `TimelineBands`), `Filmstrip`, `PreviewViewport` (with `PreviewSurface` and `ViewportMath`: the crop box's handles, hit-test order, drag, keyboard nudges once selected, the straighten grid and the automation value; the math in Core `CropFrame`), `CurveEditor`, `SequenceCard`, `VirtualizingWrapPanel`, `SegmentedControl`, `SplitButton` (owner review 1, R3: hierarchical, two-line menu entries, `RenderMenuItem` of kind preset, header, separator, command or submenu, styled in `Themes/Visuals.xaml`) |
|
||||
| `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; `videos-<id>-<ticks>` entries restored through the videos library); `VideoEndpoints` (owner review 1, R9): `/api/v1/videos` list and get (Read), delete with a dry run and fingerprint (Delete, audited `videos_deleted`, `sequenceChanged` `renders`), copy as a `video-copy` job into `ServerOptions.VideosPath` (Edit, audited `videos_copied`), library refusals mapped to 409, 422 and 507; `SystemEndpoints` announcing the `videos` capability; `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; a sent render or a node's result recorded with its verified SHA-256 and kind); `FileResponses` (Range requests, the media types of `.webm`, `.m4v` and `.apng`); the archive module sets `Videos.ProtectedFolders` to the data folder; `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; `RoutedAsync` routes a job again from the sequence's settings of the moment, and a node that reads an older settings format, or cannot encode the adapted size, never claims it), monitor and availability (`RenderNodeAvailability` waits for a node only while one would take the routed job). Owner review 5: `Jobs/ProgressGate` (500 ms per job, 50 ms slack, shared by `JobEngineHost` and `RenderNodeService`, #65); `JobEngineHost` relays an external engine in hosted mode and `Exposes` only server kinds; `Storage/ServerEventBridge` (#67) |
|
||||
| `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; a sent render or a node's result recorded with its verified SHA-256 and kind); `FileResponses` (Range requests, the media types of `.webm`, `.m4v` and `.apng`); the archive module sets `Videos.ProtectedFolders` to the data folder; `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; `RoutedAsync` routes a job again from the sequence's settings of the moment, and a node that reads an older settings format, or cannot encode the adapted size, never claims it), monitor and availability (`RenderNodeAvailability` waits for a node only while one would take the routed job). Owner review 5: `Jobs/ProgressGate` (500 ms per job, 50 ms slack, shared by `JobEngineHost` and `RenderNodeService`, #65); `JobEngineHost` relays an external engine in hosted mode and `Exposes` only server kinds; `Storage/ServerEventBridge` (#67). Owner review 6, #73: `Storage/PhotoLookup` (raw SQL in batches of 500, scoped to the served archive: frames by SHA-256, tombstones, unhashed photos by size and capture millisecond, session keys; ids and counts only) behind `Api/PhotoLookupEndpoints` (`POST /api/v1/photos/lookup`, Read, 413 `too_many`, a 4 MB body limit); `UploadService` with `IntoTarget` (target checks, `UploadRules.StandIn` with the target only, `UploadRules.CopySource`, a verified server-side copy into the target, `copied`); `SystemEndpoints` announcing `photo-lookup` and `upload-into` (the desktop's share too). The server runs neither `Integrate` nor `MergeSequences` |
|
||||
| `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, and names `videos` entries with their own Restore message; `audit.js` reads `archive_converted` as a sentence; `videos.js` the Videos page (owner review 1, R9: cards or list, filters in the address, `#/videos?sequence=<id>`, selection, Play in a `<video>` or `<img>` dialog, Download, Copy to folder and Delete… with its dry run; it calls only the videos endpoints and the render file, never a project or render route), its `videoKind`, `kindText` and `shortHash` shared with `sequence.js`'s renders; `settings.js`' *Videos folder*, locked by `CHRONOS_VIDEOS_PATH`). Owner review 5, #67: `HostedServer` (`HostedEngine`, `DesktopHostLifetime`), `ServerHost.BuildHosted`, `ServerOptions.ForHosted`/`ApplyDesktop`; `Api/ServedItems` (by-id routes scoped to the served archive); `Security/ClientActivity`; the server id (`ServerHost.ServerIdAsync`, app setting `server.id`, #66); the Windows service host is gone |
|
||||
|
||||
### 2.5 Hosts
|
||||
@@ -133,6 +134,8 @@ Dependencies point one way: `Core` ← `Core.Windows`, `Data`, `Protocol` ← `S
|
||||
| `WorkspaceSend` (22) | `Workspaces/WorkspaceSendJobHandler` (phase 5c, `WorkspaceJobs.Send`: the ledger's unsent renders filed in this PC's archive or uploaded to the server with their project and version, the version pushed first when the home lacks it, idempotent by render id; normal by default; a server send waits while `HoldTransfers` is true) | yes | no |
|
||||
| `WorkspaceMove` (23) | `Workspaces/WorkspaceMoveJobHandler` over `WorkspaceMover` (phase 5c, `WorkspaceJobs.Move`: the workspace folder moved with its projects after a confirmed plan, journaled, resumable, undone on failure or cancel before its switch; an `ICancelledJobHandler`; high by default) | yes | no |
|
||||
| `VideoCopy` (24) | `Videos/VideoCopyJobHandler` (owner review 1, R9, via `ArchiveService.CreateJobHandlers`: renders copied hash-verified into a videos folder, `VideoCopyParameters`; on the desktop a server's renders downloaded through the sync remote) | yes | yes |
|
||||
| `Integrate` (25) | `Copies/IntegrateJobHandler` (owner review 6, #73, via `CopyJobs.CreateHandler`, registered by `AppServices`: a local sequence and its server match completed both ways by a confirmed `IntegratePlan`, `IntegrateJobParameters` with the plan's fingerprint and context; planned again on the first run, then driven by its journal; high by default; held on a metered connection) | yes | no |
|
||||
| `MergeSequences` (26) | `Archiving/Jobs/MergeJobHandler` (owner review 6, #73, via `SequenceMerger.CreateHandler` with `ProjectTransplant` and the workspace guard: two local sequences merged into the kept one, `MergeJobParameters`; the other to its archive's trash after every photo is verified; high by default) | yes | no |
|
||||
| `Adopt` | none: done synchronously (`ArchiveService` actions) | — | — |
|
||||
|
||||
A job engine claims only kinds it has handlers for. Light analysis is queued by the engine (`JobContext` follow-up)
|
||||
|
||||
+211
-8
@@ -394,7 +394,11 @@ Primary entities (identical concepts in SQLite and PostgreSQL; ids are UUIDv7 st
|
||||
sent home with their project and version; workspace-move, stored as 23, the workspace
|
||||
folder moved with its projects; all three run by the desktop only: amended 2026-10-26, R8;
|
||||
video-copy, stored as 24, renders copied hash-verified into a videos folder, desktop and
|
||||
server: amended 2026-11-05, owner review 1 R3/R8/R9), target ids, state (queued, running, paused, done, failed, cancelled),
|
||||
server: amended 2026-11-05, owner review 1 R3/R8/R9; integrate, stored as 25, a local
|
||||
sequence and its server match completed both ways by a confirmed plan, then linked;
|
||||
merge-sequences, stored as 26, two sequences of this PC merged into the kept one, the other
|
||||
into its archive's trash once every photo is verified; both run by the desktop only:
|
||||
amended 2026-11-16, owner review 6 R3), target ids, state (queued, running, paused, done, failed, cancelled),
|
||||
progress (done/total, fps, eta; and a detail: step, current item, item x of y, part n of m
|
||||
with its unit, stored as `jobs.progress_detail`, migration 0011, so a paused or failed job
|
||||
keeps where it stopped: amended 2026-11-15, owner review 5 R2), log tail, created by, node
|
||||
@@ -413,6 +417,16 @@ Primary entities (identical concepts in SQLite and PostgreSQL; ids are UUIDv7 st
|
||||
R7), reason (deleted, replaced), removed at. Written from the sidecar's `removed` list (§7)
|
||||
at every index sync, so a rebuild keeps it, leaving out content a frame of the sequence
|
||||
holds again; it goes with its sequence row and outlives the trash entry.
|
||||
- **FoundCopy** (client; amended 2026-11-16, owner review 6 R1) — a *match*: two sequences
|
||||
Chronos believes hold one time-lapse, a local sequence and a sequence of one server, or two
|
||||
sequences of this index; kind, evidence (link, session key, hashes, size and time), scores
|
||||
(shared, only here, only there, deleted here, deleted there, containment, overlap, hints),
|
||||
state (candidate, kept apart, linked, integrating, integrated), the fingerprint of what was
|
||||
answered, the integrating job, the photo policy, whether new photos move by themselves, and
|
||||
the 404 record of the server sequence. **CopyProbe** — what detection last compared for a
|
||||
local sequence and a server (frames version, hashed count, the server's newest update time
|
||||
it saw), per sequence and scope (a server, or this PC). Both go with their sequence rows;
|
||||
detection finds a pair again.
|
||||
- **MediaCard** (client) — id, volume serial, filesystem label, capacity, nickname, camera
|
||||
identity (Make/Model/BodySerial from first file), profile JSON, first/last seen, import
|
||||
history (job ids).
|
||||
@@ -436,7 +450,10 @@ Main, both on live rows only, `project_versions(project_id, number)` (migration
|
||||
`renders.project_id` and `renders.project_version_id`; amended 2026-10-26, R8),
|
||||
`renders(created)` and `render_copies(render_id)` (migration 0010, with `renders.sha256`,
|
||||
`renders.kind` and the table `render_copies`, no backfill; amended 2026-11-05, owner review 1
|
||||
R3/R8/R9).
|
||||
R3/R8/R9), `found_copies(local_id, server, remote_id)` and `found_copies(local_id, other_id)`
|
||||
(unique per kind), `found_copies(server, remote_id)`, `(other_id)` and `(state)`, and
|
||||
`copy_probes(sequence_id, scope)` (the key; migration 0012; amended 2026-11-16, owner review 6
|
||||
R1).
|
||||
Paging everywhere (keyset pagination on `(first_capture, id)`).
|
||||
|
||||
---
|
||||
@@ -484,6 +501,12 @@ cache part runs. Nothing is deleted. A toast reports *Folders sorted* (with *Ope
|
||||
(a Guid v7 made at first start) in its database, so a restore keeps it and a fresh database
|
||||
makes a new one.
|
||||
|
||||
Matches (amended 2026-11-16, owner review 6 R1): migration 0012 (SQLite and PostgreSQL) adds
|
||||
`found_copies` and `copy_probes` (§5) and turns every existing link that has a local sequence
|
||||
into a linked pair, so a later server deletion and the pair's photo policy have a row. A
|
||||
re-key of a server's links (owner review 5 R3) moves its pairs and probes in the same
|
||||
transaction.
|
||||
|
||||
- Binding: `Chronos.Core.Windows/Sqlite/WinSqlite3.cs` P/Invoke to `winsqlite3.dll`
|
||||
(`sqlite3_open_v2`, `prepare_v2`, `step`, `reset`, `finalize`, `bind_*`, `column_*`,
|
||||
`exec`, `errmsg`, `last_insert_rowid`, `changes`, `busy_timeout`, `libversion`,
|
||||
@@ -1300,6 +1323,12 @@ player smoke test on Windows CI.
|
||||
sequence opened last on this PC, else *Open in workspace* asks which. A server-only
|
||||
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).
|
||||
- Matches (amended 2026-11-16, owner review 6 R1/R6): a local sequence in a match that needs
|
||||
attention carries a Warning status, *Also elsewhere* (its tooltip names the server and the
|
||||
share of photos shared, or the other archive) or *Deleted there* (the match deleted photos
|
||||
this one still holds), on its card and in the list. *Compare…* in the card's context menu and
|
||||
the list row opens Server › Matches searched by the sequence's title. The statuses survive a
|
||||
refresh of the Library.
|
||||
|
||||
### 12.3 Edit (amended 2026-10-16, R7; formerly "Sequence editor"; amended 2026-10-26, R8; amended 2026-11-04, owner review 1 R5/R6)
|
||||
|
||||
@@ -1331,7 +1360,10 @@ player smoke test on Windows CI.
|
||||
state chip read from its home after the list shows) above *Library*; the search filters
|
||||
both, and Enter opens a library match, a project only when no sequence matches. A
|
||||
Workspace row's context menu and the Delete key offer *Remove local copy*, also for a copy
|
||||
that cannot open.
|
||||
that cannot open. Amended 2026-11-16, owner review 6 R5: a Workspace row whose time-lapse
|
||||
(a linked or integrated match) also has a workspace project at the other home shows a muted
|
||||
*Twin* chip right after the project name, its tooltip naming the other home (the server by
|
||||
name) and project.
|
||||
- The steps form a guided path, freely navigable: **Analysis** (every finding of the
|
||||
analyses with the step that deals with it; light, flicker, exposure steps received,
|
||||
shake and flagged frames; Analyse), **Frames** (virtualized table: index, time,
|
||||
@@ -1688,6 +1720,26 @@ is a Job (resumable, cancellable, logged). Recurring scans, integrity checks, th
|
||||
proxies, analyses, maintenance, backups, clean-ups and reports are schedules in Jobs ›
|
||||
Scheduled (§12.6, §14.6); the buttons here run them once (amended 2026-10-26, R10).
|
||||
|
||||
Merge sequences (amended 2026-11-16, owner review 6 R3/R4). Merging is built as the merge of
|
||||
a local match (§12.7 Matches): two sequences of this index that hold one time-lapse, in this
|
||||
PC's archive, an adopted folder or a server's originals archive. Split is not built. The
|
||||
merge dialog is the Compare dialog with *Kept* and *Other* in place of this PC and the server:
|
||||
the user chooses the kept sequence (preselected only when exactly one of the two is linked
|
||||
and lies in a server's originals archive), the photo policy for differing photos (*Kept one
|
||||
wins* or *Other one wins* besides Union and Choose each; photos only in the other always
|
||||
come), each differing detail, and sees the plan: photos into the kept one, versions kept or
|
||||
replaced, last copies first, renders moved, projects copied across (always, under free
|
||||
names), session keys and links moved, the other to the trash. The plan is blocked while
|
||||
either sequence is busy, offline, moved, linked to the same server as the other, holds
|
||||
workspace work not sent home, has a detail not chosen, holds a damaged photo nothing else
|
||||
holds, or the space is short (512 MiB kept free). *Merge* asks to type the other's photo
|
||||
count, then the `merge-sequences` job copies and files the other's photos (hash-checked,
|
||||
tombstones honoured), moves the renders, re-hashes every original of the other against the
|
||||
kept one, sends the losing versions to the photo trash, writes the details, copies the
|
||||
projects, moves keys and links, and moves the other into its archive's trash only at the
|
||||
frames version it verified. Its journal resumes each stage after a crash; a retry whose pair
|
||||
was answered meanwhile, or whose other sequence changed, plans again instead.
|
||||
|
||||
Maintenance › *Trash…* (amended 2026-10-26, R6) lists the archive's trash (§7), newest
|
||||
first: deleted sequences and photos deleted from sequences, each with its kind, photos,
|
||||
size, folder and when it went, and *Restore*. A sequence goes back as its folder is (into
|
||||
@@ -1950,6 +2002,83 @@ keeps sending originals to this PC's archive; a sequence with a local copy keeps
|
||||
originals into that copy's archive; copies already downloaded stay where they are. The
|
||||
originals archives are scanned after each finished scheduled scan of this PC's archive.
|
||||
|
||||
Matches (amended 2026-11-16, owner review 6 R1–R4, R6, R7). One time-lapse may be on a server
|
||||
and on this PC under different ids, or twice on this PC. Chronos finds these *matches* and
|
||||
lets the user choose what to do with each:
|
||||
- Detection. Server matches are looked for after each sync refresh, outside the sync's
|
||||
gate: this PC's unlinked sequences whose photos changed since they were last probed, or
|
||||
that a newer server sequence may match, send up to 64 sampled photos each (by SHA-256,
|
||||
conversions followed, and by size and capture time) to `POST /api/v1/photos/lookup`; hits
|
||||
are compared exactly by manifest (the frames list too when a side has unhashed photos), at
|
||||
most 50 per refresh. An older server without `photo-lookup` is compared by 1.1's rule, the
|
||||
hints (capture range, camera, interval, title words) and session keys, at most 20 per
|
||||
refresh, and offers no Integrate. Local matches (two sequences of this index sharing
|
||||
photos, a session key, or a link to the same server sequence) are looked for 30 s after the
|
||||
index opens and 10 s after a Scan, Rebuild, Verify, Import, Download, Convert, merge,
|
||||
Integrate or Empty trash ends. A folder of sequences kept elsewhere is added with *Adopt
|
||||
folder…* and compared like any archive; there are no watched folders. *Find matches*
|
||||
probes everything again.
|
||||
- *Link matches* (Settings › Server, §12.8) decides what a server match becomes: *Ask
|
||||
always* (default) lists it; *When identical* links it when both sides hold exactly the same
|
||||
photos by SHA-256; *Half shared* keeps 1.1's rule (the same first second and camera, half
|
||||
the photos shared). A local match is always asked. New matches raise a toast "{n} matches
|
||||
found" · *Review*; links made by themselves "{n} sequences linked" · *Show*.
|
||||
- Server › *Matches* (a chip after Conflicts, shown while signed in or while the index has
|
||||
more than one archive) lists the pairs, attention first: Sequence, This side, Other side,
|
||||
State (*match found*, *kept apart*, *linked*, *integrating · x of y*, *merging*,
|
||||
*integrated*, *deleted there · n*, *deleted on server*, *kept here*) and the actions of the
|
||||
state: *Compare…*, *Integrate…* (*Merge…* for a local pair), *Keep apart*, *Ask again*,
|
||||
*Unlink*, *Review*, *Keep here*, *Upload again*, *To trash…*. A disabled action says why.
|
||||
*Keep apart* and *Unlink* toast with *Undo*; *Keep apart* is remembered and asked again
|
||||
only when the match becomes identical or its shared photos grow by the larger of 10 and a
|
||||
quarter of those shared when it was answered. The rail badge counts conflicts and matches that need attention. In the sync table
|
||||
a sequence in an unanswered match reads *match found* with *Compare…* first, and a linked
|
||||
one offers *Compare…* last.
|
||||
- The Compare dialog (in the section, Esc closes it) has four parts. *Photos*: the photo
|
||||
choice for this run and a class table (same, same unverified, only here, only there,
|
||||
different, converted, deleted here, deleted there, two versions) with counts and sizes per
|
||||
side; a class lists its photos, with *Bring* for photos on one side under *Choose each*
|
||||
(nothing preselected), *Keep both / This PC's / Server's / Leave* for different ones,
|
||||
*Drop…* for two versions, *To trash…* for photos deleted there and *Delete on server…* for
|
||||
photos deleted here (the owner of the server sequence or an admin, with Delete). *Details*:
|
||||
one row per title, tags, rating, notes and setting, each side's value and a choice *This
|
||||
PC | Server* with nothing preselected, *All this PC* / *All server* above. *Projects*:
|
||||
*Copy across | Leave them* and each side's projects with where each goes. *Plan*: what each
|
||||
side receives, sends, keeps in two versions, sends to the trash (last copies first), the
|
||||
details changed, projects copied, free space and quota left, whether new photos will move
|
||||
by themselves, and each block with its reason and, where one exists, the action that
|
||||
clears it; *Link only* (a server match not linked yet) links without moving anything.
|
||||
- *Integrate* (local and server; R3, owner Q2 "Completa entrambe") is blocked while a detail
|
||||
has no choice (the dialog then opens on Details), either side is busy or gone, the server
|
||||
lacks `upload-into` or the account may not add to or delete from its sequence as the plan
|
||||
needs, or space is short. A plan that replaces photos asks first (*Replace photos?*, the
|
||||
losing versions listed under the side that loses them). The `integrate` job links the two,
|
||||
moves the photos each side lacks both ways (never creating or retargeting a server
|
||||
sequence), sends a losing version to the trash only after the winner is confirmed by hash
|
||||
on that side (on the server through a dry run, then at the frames version it read; the
|
||||
server allows it to the sequence's owner or an admin), writes the agreed details to both
|
||||
sides as one change, and copies the projects (§14.5). Its journal resumes each stage; a
|
||||
retry after the user answered the pair otherwise refuses.
|
||||
- After an Integrate that left nothing out, the pair is *integrated*: its new photos move by
|
||||
themselves both ways (§14.5); three failures in a row raise "{title}: photos not sent" ·
|
||||
*Show* and the row reads *not sent* with the reason. An Integrate that left photos out
|
||||
keeps manual transfers and says so.
|
||||
- Deleted there: photos the other side deleted that this side still holds read *deleted
|
||||
there · n* with *Review* (the dialog on that class) and go to this PC's trash only through
|
||||
*To trash…*, after a dry run and a confirmation naming last copies, and only while the other
|
||||
side still has them deleted.
|
||||
- Deleted on server: a linked server sequence that answers 404 is marked once per refresh
|
||||
(only on a server known by its id, at most once every 10 minutes, never in a sweep where 5
|
||||
or more links answer 404 and none answers); a second 404 at least 10 minutes later makes
|
||||
the row read *deleted on server*, with *Keep here* (then *kept here*, *Upload again*
|
||||
only), *Upload again* (a new server sequence) and *To trash…* (the Library's delete, last
|
||||
copies named). A sequence that comes back is linked or asked again.
|
||||
- *Upload all local* (R7, owner Q8 "Saltale e segnalale") skips sequences in an unanswered or
|
||||
kept-apart match, in an integrating pair or a job's hands, whose server copy was deleted,
|
||||
or in any server's originals archive; each skipped row reads *skipped* with the reason
|
||||
(where the suspected match lies), and the toast "Queued: {0} · skipped: {1}" · *Show*
|
||||
lists them first.
|
||||
|
||||
### 12.8 Settings
|
||||
|
||||
Sections (list on the left, controls on the right, no descriptions — tooltips only):
|
||||
@@ -1968,7 +2097,8 @@ profile, memory budget, spill folder, parallelism = photos the running job proce
|
||||
with a level per job kind, encoders detected, hardware preference; amended 2026-10-16, R2;
|
||||
Workspace copy listed, high by default, as Download, and Local render high, Send render
|
||||
normal and Move workspace high: amended 2026-10-26, R8; Copy videos high: amended
|
||||
2026-11-05, owner review 1 R3/R8/R9),
|
||||
2026-11-05, owner review 1 R3/R8/R9; Integrate and Merge sequences high: amended 2026-11-16,
|
||||
owner review 6 R3),
|
||||
Formats (per
|
||||
format tier on this PC, codec install links), Storage, Workspace (amended 2026-10-26, R8:
|
||||
*Folder*, the path read-only with *Open* and *Change…*, which shows a plan (projects left,
|
||||
@@ -2007,6 +2137,15 @@ short server id (the full id in the tooltip), *Signed in* or *Offline*, the orig
|
||||
and the server's cache share, each with *Open*. The settings Chronos Desktop owns are shown
|
||||
in the shared library's admin panel as "Set in Chronos Desktop".
|
||||
|
||||
Owner review 6 (amended 2026-11-16, R1/R4/R5): Server gains three rows after *Default
|
||||
server* and before *Render node*, found by searching "Matches": *Link matches* (*Ask
|
||||
always*, default; *When identical*; *Half shared*: owner Q1 "Mettere la scelta come
|
||||
parametro, default chiedere sempre"), *Integrate photos* (*Union*, default; *Choose each*;
|
||||
*This PC wins*; *Server wins*: owner Q3 "default unione") and *Integrate projects* (*Copy
|
||||
across*, default; *Leave them*: owner Q5 "default copiali dall'altra parte"). Each option has
|
||||
its own tooltip. The Compare dialog starts from them and can change them for one run. Reset
|
||||
restores the defaults; Export and Import carry them.
|
||||
|
||||
### 12.9 About
|
||||
|
||||
The last page of Settings (§12.8), no longer an entry of the rail (amended 2026-10-26, R5):
|
||||
@@ -2172,7 +2311,8 @@ GET/PATCH {name}/DELETE /sequences/{sid}/projects/{pid} · GET …/{pid}/head ·
|
||||
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?}
|
||||
POST /api/v1/uploads {sequenceId|null, fileName, size, sha256, capturedAt?, sessionKey?, restore?, intoTarget?} → {uploadId, chunkSize, received[]} | 200 {alreadyExists, frameId?, copied}
|
||||
POST /api/v1/photos/lookup {probes: [{key, sha256[], unhashed?[], sessionKey?}]} → {results: [{key, hits: [{sequenceId, hashes, removed, unhashed, sessionKey}]}]} (Read; owner review 6)
|
||||
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)
|
||||
GET /api/v1/uploads/{id} resume state
|
||||
@@ -2475,6 +2615,24 @@ projects as this PC's archive does (§7), and `server/info` lists the capability
|
||||
carries the render's `projectId` and `projectVersionId`, null when none. An older server
|
||||
ignores both fields; the desktop notes it in the job's log.
|
||||
|
||||
Matches (amended 2026-11-16, owner review 6 R1/R3). `server/info` announces the capabilities
|
||||
`photo-lookup` and `upload-into`; a client reads them once per server and treats an older
|
||||
server as having neither.
|
||||
- `POST /api/v1/photos/lookup` (Read) answers, for each probe (a local sequence's sample of
|
||||
SHA-256, unhashed photos by size and capture time to the millisecond, and its session key),
|
||||
the sequences of the served archive that hold those hashes in a frame, tombstoned them
|
||||
(deleted or replaced by a conversion), match the unhashed photos, or are filed under the
|
||||
session key: ids and counts only, never another archive of the index. At most 200 probes
|
||||
and 20,000 items per request (413 `too_many`), a 4 MB body limit.
|
||||
- `intoTarget: true` on `POST /api/v1/uploads` files the photo into `sequenceId`, which must
|
||||
be given (400), belong to the served archive (404) and be the caller's own, or the caller an
|
||||
admin or an editor (403 `forbidden`); it never goes with `restore` (400). Only a copy in
|
||||
the target stands in for the photo, and a photo the target deleted answers `alreadyExists`
|
||||
with no frame. When another sequence of the served archive holds the photo intact, the
|
||||
server files a verified copy of that file into the target without the bytes crossing the
|
||||
wire and answers `copied: true` with the new frame (§14.4). Without `intoTarget` nothing
|
||||
changes.
|
||||
|
||||
### 14.4 Upload and ingest
|
||||
|
||||
Client computes SHA-256 while reading; `POST /uploads` short-circuits if the hash exists;
|
||||
@@ -2490,6 +2648,17 @@ answers 507 with the upload still receiving, so the client completes it again on
|
||||
room; render uploads and render-node results are checked the same way at completion, and a
|
||||
volume that cannot be measured refuses nothing (amended 2026-10-26, R2).
|
||||
|
||||
Uploads into a target (amended 2026-11-16, owner review 6 R3): with `intoTarget` (§14.3) an
|
||||
upload whose photo the target lacks, but another sequence of the served archive holds, is
|
||||
copied on the server: the quota (403 `quota_exceeded`) and the archive's room (507) are
|
||||
checked, the file is copied into staging and its SHA-256 compared (a mismatch or an IO error
|
||||
falls back to an ordinary upload), then it is committed into the target refusing removed
|
||||
photos, charged to the quota only when it makes a new frame, and announced with the frames
|
||||
change event. A busy, offline or moved target answers 503. The desktop uploads a linked
|
||||
sequence this way whenever the server has `upload-into`, so a linked pair whose photos the
|
||||
server held elsewhere now reaches *in sync*; if the server refuses (403) it goes on with
|
||||
ordinary uploads, which the server files by SHA-256.
|
||||
|
||||
Deleted photos (amended 2026-10-26, R6): a photo deleted from a sequence is not filed into it
|
||||
again by an upload. `POST /uploads` answers a SHA-256 the target sequence tombstoned, and none
|
||||
of its frames still holds, with `alreadyExists` and no frame id, so an old client syncing a
|
||||
@@ -2570,6 +2739,20 @@ missing here and *Download* fetches and drops it each time; a photo never hashed
|
||||
original was already missing when it was deleted leaves no tombstone, so a copy elsewhere
|
||||
(another PC, a card) is not known to be deleted and can come back.
|
||||
|
||||
Matches and integrated pairs (amended 2026-11-16, owner review 6 R1/R6). A refresh no longer
|
||||
links a local sequence to a server one by content by itself: the *Link matches* setting
|
||||
decides (§12.7), *Ask always* by default, and every link has its pair. For an *integrated*
|
||||
pair whose Integrate left nothing out, the sync agent queues after each refresh, at
|
||||
background priority, an upload of the photos the server lacks and a download of the
|
||||
originals this PC lacks into the local sequence's own archive (owner Q6 "Foto nuove in
|
||||
auto"); such a transfer never creates or retargets a sequence, never runs for a pair whose
|
||||
server sequence answered 404, is held on a metered connection whatever *Pause metered
|
||||
transfers* says, never interrupts a running job, and backs off after a failure. Settings of
|
||||
an integrated pair sync exactly as for any link. A photo deleted on one side of a linked or
|
||||
integrated pair is never deleted on the other by sync: it is counted as *deleted there* and
|
||||
goes to the trash of the other side only when the user confirms it (*To trash…*, or *Delete
|
||||
on server…* for the server).
|
||||
|
||||
Converted photos (amended 2026-10-26, R7). Every replaced tombstone of either side links two
|
||||
encodings of one photo, and the encodings these links join (a conversion, a conversion of it,
|
||||
its undo, each side converting its own copy) compare, transfer and translate as one photo,
|
||||
@@ -2611,7 +2794,15 @@ only settings both sides changed are a conflict. Versions are compared and place
|
||||
(the portable form), so photos added, a copy's other frame order, a Verify that hashed a
|
||||
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
|
||||
through the settings sync above; other projects never leave their home by themselves
|
||||
(amended 2026-11-16, owner review 6 R5): an Integrate of two matches with *Copy across*
|
||||
(the default, owner Q5 "Scelta, default copiali dall'altra parte") copies each side's other
|
||||
projects, with their histories, to the other home, named `<name> (<PC>)` (or `<name>
|
||||
(<server>)`) on a clash; a merge of two local sequences always copies the other's projects
|
||||
into the kept one; with *Leave them* they stay, and the two workspace copies are marked as
|
||||
twins in Edit (§12.3). A copied version is verified against its content hash at the other
|
||||
home, a copy someone else changed meanwhile is left alone and a new name taken, and a
|
||||
project of a newer settings format is not copied. A home that is
|
||||
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).
|
||||
|
||||
@@ -2686,7 +2877,12 @@ holds its project now, and fails, to be retried, while a move is under way. *Cop
|
||||
and the server, high by default as a download is: it copies the renders its parameters
|
||||
name into the host's videos folder, checking that folder again when it runs (never the
|
||||
archive, the data folder or the workspace), each file verified by hash before it takes its
|
||||
name (§12.10), and resumes after the copies it finished. A
|
||||
name (§12.10), and resumes after the copies it finished. *Integrate* (`integrate`, stored as
|
||||
25) and *Merge sequences* (`merge-sequences`, 26; amended 2026-11-16, owner review 6 R3) run
|
||||
on the desktop only, high by default; each plans again on its first run and refuses a plan
|
||||
whose fingerprint moved, then follows its journal in `.chronos/journal/` stage by stage, and
|
||||
releases its pair on a cancel. A job of background priority (an integrated pair's automatic
|
||||
transfers) never makes a running job yield, whatever its level. A
|
||||
handler may clean up after a cancel: cancelling a paused or failed job no handler runs calls
|
||||
it, and cancelling a paused job whose run has not ended waits for that run to end first
|
||||
(amended 2026-10-26, R8).
|
||||
@@ -3609,6 +3805,10 @@ questions asked and the answers; DECISIONS rows give the reasons.
|
||||
| 2026-11-15 | Owner review 5, R2 (mass-pass progress, #65) | §5, §12.5, §12.6, §12.7, §14.3, §14.6, §14.8 | Jobs report a detail (step, item, item x of y, part n of m; `jobs.progress_detail`, migration 0011; `detail` on `JobDto`, `jobProgress` and `NodeProgress`), published at most twice a second per job (engine and server gate 500 ms); the Jobs rows, the job bar (60 characters), Archive › Recent maintenance, the editor's server job line and the admin panel's Jobs and dashboard show it; the desktop's Server section lists the connected server's running and paused jobs live, with Pause, Resume and Cancel only for ManageArchive. |
|
||||
| 2026-11-15 | Owner review 5, R3 (separate homes, #66) | §4.4, §6.2, §12.7, §12.8, §14.3 | Each server has a stable id (`server.id`, `serverId` in `server/info`); the desktop keys servers by it with addresses as aliases; the workspace and the cache are split into `local\` and `servers\<id>\` homes (parent manifest format 2), sorted from the 1.0 layout at the first start by journaled, inventory-checked renames; a server's homes are re-keyed at sign-in; *Download originals* goes to the server's own archive beside this PC's; Settings gain Home folders and Known servers. |
|
||||
| 2026-11-15 | Owner review 5, R4 (desktop as LAN server, #67) | §4.4, §6.2, §12.7, §12.8, §14.3, §14.8, §14.9, §18, §19.3 | The separate Windows server program and its Windows service leave the product: `Chronos.Server` is a library, `Chronos.Server.Host` the Docker and development program; Chronos Desktop shares this PC's library on the LAN (Settings › Server › *Share this library*, Server › This library), hosting the same engine in-process over its own index and archive; by-id endpoints are scoped to the served archive; the desktop refuses its own share. |
|
||||
| 2026-11-16 | Owner review 6, R1/R7 (matches, #73) | §5, §6.2, §12.2, §12.7, §12.8, §14.3, §14.5 | Chronos finds *matches*, the same time-lapse on a server and on this PC under other ids or twice on this PC (this PC's archive, adopted folders, servers' originals archives): `found_copies` and `copy_probes` (migration 0012), every existing link a linked pair; server detection after each refresh through `POST /api/v1/photos/lookup` (capability `photo-lookup`; 1.1's rule and hints on an older server), local detection after the index opens and after jobs that change photos; *Link matches* (*Ask always* by default, *When identical*, *Half shared*) replaces 1.1's silent link; Server › *Matches* with its states and actions, *Keep apart* remembered, the Library's *Also elsewhere*; a folder of sequences is adopted as an archive; *Upload all local* skips and marks suspected matches. |
|
||||
| 2026-11-16 | Owner review 6, R2/R3/R4 (compare, integrate, merge, #73) | §5, §12.5, §12.7, §12.8, §14.3, §14.4, §14.6 | The Compare dialog (Photos, Details line by line, Projects, Plan); *Link only* and *Unlink*; *Integrate* (`integrate`, 25) completes a local sequence and its server match both ways under the *Integrate photos* policy (*Union* by default, *Choose each*, one side wins for differing photos), losing versions to the trash only after the winner is hash-confirmed, the details applied as one change; the merge of two local sequences (`merge-sequences`, 26) into the kept one, the other into its archive's trash after every photo is verified, typed by photo count; both journaled and resumable; uploads into a target (`intoTarget`, capability `upload-into`) copied on the server; a background job never interrupts a running one. |
|
||||
| 2026-11-16 | Owner review 6, R5 (projects across, #73) | §12.3, §12.8, §14.5 | Other projects leave their home only through an Integrate with *Copy across* (the default of *Integrate projects*) or a merge, with their histories, `<name> (<PC>)` on a clash; with *Leave them* the two workspace copies are twins in the Edit picker. |
|
||||
| 2026-11-16 | Owner review 6, R6 (sync after integrating, #73) | §12.2, §12.7, §14.5 | New photos of an integrated pair move by themselves both ways at background priority, held on metered connections, told as *not sent* after three failures; settings sync as for any link; *deleted there* goes to the trash only on confirmation; a server sequence that answers 404 twice reads *deleted on server* with *Keep here*, *Upload again* and *To trash…*. |
|
||||
|
||||
## Appendix A — `CLAUDE.md` content (create verbatim in Phase 0, keep updated)
|
||||
|
||||
@@ -3653,4 +3853,7 @@ recommendations with reasons) · Tier (how a frame's pixels are obtained) · Pro
|
||||
stand-in) · Sidecar (`sequence.json` manifest) · Render (an exported video) · Preset
|
||||
(bundle of export values) · Sequence preset (project settings + export preset produced by
|
||||
the advisor) · Render node (client lending its GPU to the server) · Job (any long
|
||||
operation, resumable) · Card profile (import rules for a memory card).
|
||||
operation, resumable) · Card profile (import rules for a memory card) · Match (two
|
||||
sequences that hold one time-lapse, never a duplicate photo; owner review 6) · Integrate
|
||||
(complete a match both ways, then keep it in sync) · Merge sequences (two matches of this PC
|
||||
into one) · Twin (a workspace project with a sibling at the other home).
|
||||
@@ -5,6 +5,63 @@ commits follow Conventional Commits (release notes are generated from them by `C
|
||||
|
||||
## [Unreleased]
|
||||
|
||||
Owner review 6 for v1.2.0 (`docs/requests/2026-11-16-owner-review-6.md`; issue #73). Upgrading from 1.1 keeps the
|
||||
archive, the database and the settings: migration 0012 runs at start and turns every existing link into a linked
|
||||
match. A 1.1 server works as before, without Integrate; a 1.2 server adds the photo lookup and uploads into a target.
|
||||
|
||||
### Added
|
||||
- **Matches** (R1, R7):
|
||||
- Chronos finds the same time-lapse on a server and on this PC under different ids, or twice on this PC (this PC's
|
||||
archive, an adopted folder, a server's originals archive), by shared photos, unhashed photos of the same size and
|
||||
capture time, session keys and links. Server matches are looked for after each sync refresh; matches on this PC 30 s
|
||||
after start and 10 s after a scan, verify, import, download, conversion, merge, integration or emptied trash.
|
||||
- Server › *Matches* lists them, attention first, with their state (*match found*, *kept apart*, *linked*,
|
||||
*integrating · x of y*, *merging*, *integrated*, *deleted there · n*, *deleted on server*, *kept here*) and the
|
||||
actions of each state; *Find matches* looks again. Toasts tell new matches ("{n} matches found" · *Review*) and
|
||||
matches linked by themselves. The Server rail badge counts matches that need attention.
|
||||
- *Keep apart* is remembered (asked again only when the match becomes identical or grows a lot); *Link only* links
|
||||
without moving anything; *Unlink* keeps the two apart. Both toast with *Undo*.
|
||||
- Library cards and list rows show *Also elsewhere* or *Deleted there*, with *Compare…*.
|
||||
- A folder of sequences kept elsewhere is added with *Adopt folder…* and compared like any archive.
|
||||
- **Compare** (R2): an in-window dialog with four parts. *Photos* classes every photo (same, same unverified, only
|
||||
here, only there, different, converted, deleted here, deleted there, two versions) with counts and sizes per side and
|
||||
lists each class; *Details* puts each differing title, tag, rating, note and setting side by side to choose line by
|
||||
line; *Projects* shows each side's projects and where they go; *Plan* is the dry run, with every block and its
|
||||
reason.
|
||||
- **Integrate** (R3, R4): a local sequence and its server match each receive the photos they lack (*Union* by default:
|
||||
a differing photo is kept in both versions; *Choose each*; *This PC wins*; *Server wins*), the chosen details are
|
||||
written to both as one change, the other projects are copied across, then the two stay linked. Losing versions go to
|
||||
the trash only after the winner is confirmed by hash, and a plan that replaces photos asks first. The *Integrate* job
|
||||
resumes after a crash at each stage. *Drop…* trashes one of two versions on both sides.
|
||||
- **Merge sequences** (R3): two matches on this PC are merged into the kept one; the other goes to its archive's trash
|
||||
only after every one of its photos is verified in the kept one. The confirmation asks to type its photo count; the
|
||||
*Merge sequences* job resumes after a crash at each stage and moves renders, projects, session keys and links.
|
||||
- **Projects across** (R5): an Integrate with *Copy across* (the default) copies each side's projects, with their
|
||||
histories, to the other home, named "name (PC)" on a clash; with *Leave them* the Edit picker marks the two workspace
|
||||
copies *Twin*.
|
||||
- **After integrating** (R6): new photos of an integrated pair move by themselves both ways, paused on metered
|
||||
connections and never interrupting a running job; three failures in a row read *not sent* and raise a toast. Photos
|
||||
the other side deleted read *deleted there · n* and go to the trash only through *Review* › *To trash…*. A server
|
||||
sequence that answers 404 twice reads *deleted on server*, with *Keep here*, *Upload again* and *To trash…*.
|
||||
- **Settings › Server**: *Link matches* (*Ask always*, *When identical*, *Half shared*), *Integrate photos* and
|
||||
*Integrate projects*, each option with its tooltip.
|
||||
- **Server**: `POST /api/v1/photos/lookup` (Read; 200 probes and 20,000 items at most) and `intoTarget` on
|
||||
`POST /api/v1/uploads`, which files a photo into the target by copying, on the server, a file another sequence of the
|
||||
served archive holds (`copied` in the answer); `server/info` announces `photo-lookup` and `upload-into`.
|
||||
- Jobs: *Integrate* (stored as 25) and *Merge sequences* (26), high in the priority queue, with their own detail steps.
|
||||
|
||||
### Changed
|
||||
- A sync refresh no longer links a local sequence to a server one by content by itself: *Link matches* decides, and
|
||||
*Ask always* is the default (1.1's rule is *Half shared*).
|
||||
- *Upload all local* skips suspected and kept-apart matches, sequences being integrated or merged, sequences whose
|
||||
server copy was deleted and sequences of a server's originals archive; each skipped row reads *skipped* with the
|
||||
reason, and the toast "Queued: {0} · skipped: {1}" · *Show* lists them.
|
||||
- A linked sequence's photos are uploaded into its server sequence even when the server holds them in another sequence,
|
||||
so such a pair now reaches *in sync*.
|
||||
- A job of background priority (automatic transfers) never makes a running job yield.
|
||||
- Sync rows of a sequence in an unanswered match read *match found* with *Compare…* first; every linked row offers
|
||||
*Compare…*.
|
||||
|
||||
### Fixed
|
||||
- Found copies, review of owner review 6 (#73):
|
||||
- A server sequence forgotten on a server known only by its address is found again when it is back.
|
||||
|
||||
@@ -901,6 +901,54 @@ One line per decision: date · decision · alternative · reason.
|
||||
| 2026-11-16 | `installer-test.ps1` is not run on a PC that has Chronos installed for all users: the setup finds the all-users install when no per-user one exists and asks for elevation to upgrade or remove it. It runs on a clean Windows (the CI windows job, a VM) | Point the script at another product name | The upgrade and legacy paths it checks only exist for the product `Chronos` |
|
||||
| 2026-11-16 | The job log keeps storing each line's time in UTC (`HH:mm:ss`); the desktop shows it in local time, dating the lines backwards from the job's end (or now): each line is the latest instant at or before the next one. A pause of a day or more between two lines cannot be seen and those lines take the later day, so across a clock change they may be an hour off (#70) | Write local time into the log; store full UTC timestamps | A server's jobs are read from desktops in any time zone, logs already stored stay readable, and the stored format (shown as is by the admin panel) does not change |
|
||||
| 2026-11-16 | The Type column of Jobs and Server › Jobs is a 1* share (was 0.7*), 90–170 px, so the Italian "Analisi approfondita" fits in a 1440 px window (#70) | `Auto` shared across the rows | `Auto` keeps its width at the minimum window, where the star columns are already at their minimums, and pushed the row actions out (Dutch, 12 px) |
|
||||
| 2026-11-16 | Owner review 6 (#73): matches are a table `found_copies` beside `sync_links` (migration 0012, with `copy_probes`), not a state of the links | A group id over sequences | A copy may be in several pairs and two local sequences can be a pair; links stay one per side and server |
|
||||
| 2026-11-16 | Every existing link with a local sequence is migrated as a linked pair (random v4 ids) and every new link gets its pair (`FoundCopyStore.EnsureLinkedAsync`) (#73) | Rows only for what detection finds | The 404 mark and the pair's photo policy need a row for every link |
|
||||
| 2026-11-16 | *Link matches* defaults to *Ask always*, replacing 1.1's silent link at half shared; *Half shared* keeps 1.1's rule exactly, its same-second and camera gates included; *When identical* links only when both sides hold the same photos by SHA-256 and nothing is deleted on one side only (#73) | Keep the silent link; drop 1.1's gates; size and time as identity | Owner Q1 "Mettere la scelta come parametro, default chiedere sempre" and "today's rule"; adopted, unverified photos prove nothing |
|
||||
| 2026-11-16 | Detection compares every archive of the index (this PC's, adopted folders, servers' originals archives) with the server and with each other; no workspace scan, no watched folders (#73) | Scan the workspace's media; watch folders | Owner Q7 "Come archivio"; workspace copies follow their homes |
|
||||
| 2026-11-16 | The photo lookup sends at most 64 sampled hashes per sequence and candidates are compared by manifest, at most 50 per refresh; detection counts no Differs or Versions (#73) | Send every hash; fetch the frames of every candidate | 500,000 photos would send 32 MB per refresh; the Compare dialog counts Differs |
|
||||
| 2026-11-16 | An older server (no `photo-lookup`) gets candidates by 1.1's gate, the hints (40 or more) and session keys, at most 20 manifest comparisons per refresh, and no Integrate (#73) | Integrate without `upload-into` | Such a server would not file into the target photos it holds in another sequence |
|
||||
| 2026-11-16 | Uploads of a linked sequence use `intoTarget` on a server with `upload-into`; a server-side copy that files a new frame is charged to the quota (#73) | Use it only in Integrate; copy for free | A linked pair whose photos the server held elsewhere never reached in sync; the archive grows by those bytes |
|
||||
| 2026-11-16 | A Union keep-both files the other version as a second frame and excludes it from Main; this PC's (the kept one's) version stays included on both sides, so the server's Main and renders use this PC's version (#73) | Each side keeps its own version | One payload on both sides; the next one-sided push would switch it anyway |
|
||||
| 2026-11-16 | *This PC wins* / *Server wins* decide the differing photos only; photos on one side only always reach the other, and only replaced versions go to the trash (#73) | The losing side's only-there photos stay or go | Owner Q3 (one side wins "for differing photos") and Q2 "Completa entrambe" (each gets what it lacks) |
|
||||
| 2026-11-16 | Details with no choice block Integrate and nothing is preselected; Integrate… then opens on Details (#73) | Preselect this PC | Owner Q4 "Riga per riga": the user chooses each line |
|
||||
| 2026-11-16 | Integrate of a local pair is a merge; the kept sequence is preselected only when it is the linked one in a server's originals archive, else the user chooses (`CopyBlock.KeptUnchosen`) (#73) | This PC's archive | Adopt folder… moves the last archive to the adopted folder, so "this PC's archive" names no fixed sequence |
|
||||
| 2026-11-16 | A merge moves the other's session keys (those the kept archive does not already map), links (their agreement reset), pairs and renders (row moved, id kept) to the kept sequence (#73) | Leave them on the other | Later imports and downloads join one sequence; a moved link must not push a payload chosen against the other |
|
||||
| 2026-11-16 | A merge is blocked while the other has workspace work not sent home, checked again before its trash stage; an unreadable workspace state counts as unsent (#73) | Carry the workspace projects across | Re-homing a workspace project is not built; nothing unsent may go to the trash |
|
||||
| 2026-11-16 | A local sequence linked to a sequence of a server is not matched with another sequence of that server; the two local copies of one server sequence form a local pair instead (#73) | Merge server sequences | Out of scope for 1.2 |
|
||||
| 2026-11-16 | Projects cross through a new `ProjectTransplant` (journaled intent, versions verified against their hash, `FreeName` "name (PC)", "(2)"…) beside WorkspaceSync's Save both (#73) | Refactor Save both | No risk to the workspace engine |
|
||||
| 2026-11-16 | Settings of integrated pairs sync exactly as for any link: no stored base payload and no field-level three-way merge in 1.2; a follow-up issue asks the owner (#73) | A member-by-member merge against a stored base | Owner Q6 "settings as today" |
|
||||
| 2026-11-16 | New photos move by themselves only for integrated pairs whose plan left nothing out (`AutoPhotos`); Link only and older links keep manual transfers (#73) | A per-photo exclusion list the agent honours | Owner Q6 scopes it to integrating; the agent must never undo a per-photo choice |
|
||||
| 2026-11-16 | A 404 marks the pair; it reads *deleted on server* only after a second 404 at a later refresh from the same server id; a sweep of 404s marks nothing (#73) | Forget silently; mark on the first 404 | Never invite trashing the only copy on a transient answer; owner Q6/Q8: ask instead |
|
||||
| 2026-11-16 | *Upload all local* skips suspected and kept-apart matches, integrating and busy sequences, sequences whose server copy was deleted and every server's originals archive, the current server's too, and marks them *skipped* (#73) | Skip only other servers' archives; upload kept-apart ones as new sequences | Owner Q8 "Saltale e segnalale"; a copy in an originals archive came from a server; a new server sequence would hold only the photos the server lacks anywhere |
|
||||
| 2026-11-16 | The Import › Folder… warning for photos already on a server or in another archive is not built in 1.2 (#73) | Build it | Local detection runs after the import's scan and the server's at the next refresh, so the match shows within minutes |
|
||||
| 2026-11-16 | The Matches list shows local pairs while signed out; the chip shows while signed in or while the index has more than one archive (#73) | Only while signed in | Local pairs need no server |
|
||||
| 2026-11-16 | The row action is *Integrate…* for a local and server pair and *Merge…* for a local pair (#73) | One word for both | The merge sends a folder to the trash; the row must say so |
|
||||
| 2026-11-16 | Pairs and answers cascade with their sequence rows (trash, Rebuild, Orphans, Reidentify); detection finds them again (#73) | Key the answers by fingerprint | Simplest; a re-indexed sequence is asked about again at worst |
|
||||
| 2026-11-16 | Every linked sync row offers *Compare…* (and so Integrate) as its last action (#73) | List every plain link under Matches | Every linked sequence can be integrated without crowding the list |
|
||||
| 2026-11-16 | The UI noun is *match* / *corrispondenza* (Server › *Matches* · *Corrispondenze*), never *copy* / *copia*; code keeps `FoundCopy`, `found_copies`, `CopyEngine`; `i18n/GLOSSARY.md` gains Match, Integrate, Merge sequences, Keep apart and Twin (#73) | *Found copies* / *Copie trovate* | The photo-duplicates report owns "copie" (*Segna copie*); the 36 other cultures must keep the two apart |
|
||||
| 2026-11-16 | Owner review 6 was built in parallel parcels (P0 foundation, P1a, P2 and P6, then P1b and P4, then P3 and P5) with per-file ownership in worktrees, merged with `--no-ff`; the en and it keys came with P0, the 36 other cultures at the release step (#73) | Sequential parcels | Eight parcels in one release; no merge had a conflict |
|
||||
| 2026-11-17 | The once-per-refresh count of a server 404 is kept in memory per database (a `ConditionalWeakTable` keyed by `IDatabase`), not in the schema (#73) | A column of the refresh id | After a restart a new refresh id counts again anyway |
|
||||
| 2026-11-17 | The trash hooks' new optional parameters (`exceptJob`: the job holding the sequence is not Busy; `expectedFramesVersions`, checked under the lease) come after the `CancellationToken` of `FrameTrash` and `SequenceTrash` (#73) | Before the token, as CA1068 prefers | Existing positional callers stay unchanged; CA1068 does not fire on optional trailing parameters |
|
||||
| 2026-11-17 | `EnsureLinkedAsync` demotes the other Linked or Integrated rows of the same local sequence and server, not only those of the same remote; a merge's links stage re-points the session keys the other held in the kept archive and resets the moved pairs' frames versions (-1) so they are compared again (#73) | Demote by remote only; insert missing keys only | `sync_links` holds one link per side and server; a moved pair's counts no longer describe the kept sequence |
|
||||
| 2026-11-17 | `UploadRules.CopySource` takes a sequence-to-archive map, so a server-side copy for `intoTarget` never takes a file of another archive of the index; the copy keeps the source's original file name (`OriginalFileName ?? FileName`) (#73) | The design's four parameters; the archive's file name | A frame does not carry its archive; the new frame must not record the archive's renamed file as its original name |
|
||||
| 2026-11-17 | A photo lookup's *Removed* never counts a hash the same sequence still holds in a frame; the lookup route has its own 4 MB body limit (#73) | Count every tombstone; the 1 MB JSON limit | A stale tombstone would count one photo twice; a full 20,000-item request is about 1.4 MB |
|
||||
| 2026-11-17 | `CopyRules.Decide` takes the pair's evidence (default hashes), so a session-key pair with no shared photo is still asked; a kept-apart pair asks again on becoming identical only if it was not identical when answered (read from the answered fingerprint) (#73) | The design's signature; ask whenever it is identical | A back-reference alone is a match; a pair kept apart while identical must not be asked over and over |
|
||||
| 2026-11-17 | The last-copy check (`CopySides.HeldElsewhereAsync`) ignores frames flagged Missing or Corrupt; an unhashed photo without a capture time gets the key `u:<size>:<frame id>` and never matches (#73) | Count them as held; key them by size alone | A missing file is not a copy; photos without a time cannot be told apart |
|
||||
| 2026-11-17 | `CopyFinder` keeps per process the server pairs already compared at the same frames versions and hashed count, cleared by Find matches for its scope; it replaces 1.1's `_unmatched` (#73) | Compare the same first candidates at each refresh | A sequence with more candidates than one refresh compares would never get past its first batch |
|
||||
| 2026-11-17 | The exact comparison of detection reads the frames list too when either side has unhashed photos; lookup probes carry the other encodings conversions link to a sampled photo, 64 hashes at most (#73) | The manifest only; the sampled encoding only | A folder never verified still matches by size and time; a server holding either encoding is found |
|
||||
| 2026-11-17 | A 404 seen during an upload forgets the link without marking the pair (marks come only from refresh comparisons); a sweep is 5 or more gone links with a local copy and no linked sequence listed or answering in the same refresh (#73) | Mark on every 404 | The once-per-refresh and sweep rules must apply to every mark; a shared desktop serving another archive answers 404 for all |
|
||||
| 2026-11-17 | A reconcile that finds a linked or integrated pair with no score yet (a plain upload or download link) computes its full detection score once (#73) | Leave it at zero | Ask again after an Unlink must compare against real counts |
|
||||
| 2026-11-17 | `SyncService.ApplyAgreedAsync` writes the server first, by content, absorbing one-sided server changes and retrying a 409 up to three times, then this PC under the strict version check; a side that already holds the final payload is not written again (#73) | This PC first; write both always | A server change made meanwhile must not be lost silently; a resumed job must not write twice |
|
||||
| 2026-11-17 | The plan context (rights, names) travels with an Integrate job (`IntegrateJobParameters.Context`, a JSON copy without the id sets); a job queued without one plans with `IntegrateJobContext.Permissive` (#73) | Plan the job without the context | Rights and names change the fingerprint: the job must plan as the user's plan did |
|
||||
| 2026-11-17 | Until a server tells ownership per sequence, the desktop's plan context reads `OwnsOrAdmin` as the Delete right or an admin right (ManageArchive, ManageUsers); the server still enforces ownership on `frames/delete` (#73) | Ask the server for each sequence's owner | The client does not know who owns each server sequence; a wrong guess fails at the dry run, before anything moves |
|
||||
| 2026-11-17 | An Integrate's journal is kept after a failure (the job resumes) and deleted on a cancel and when the job finishes; a job that ends with steps or projects kept leaves the pair Linked, not Integrated, and fails with `Errors.Copies.Kept` or `ProjectsKept`; a server sequence gone during it raises `RemoteGoneException` (#73) | Keep the journal on cancel; call the pair integrated | A cancel drops the plan; a pair that kept something apart must not move photos by itself |
|
||||
| 2026-11-17 | Busy, for both planners, is a running transfer of the pair plus the pending and running jobs on the local id, its archive and the remote id, the job itself excepted; the quota left is a warning in the Integrate plan, not a block; a merge keeps 512 MiB free (#73) | `ListHoldsAsync` and `ListPendingTargetsAsync`; block on quota | One query covers transfers and jobs; the server refuses an upload over quota itself |
|
||||
| 2026-11-17 | A merge's fingerprint uses its own per-sequence frames stamp (count, bytes, hashed count, flag counts, tombstones) and a hash of each side's details, not the archive's convert stamp; Busy and Offline found by the trash dry run are reported as the merge's Busy and ArchiveOffline blocks (#73) | `GetConvertStampAsync`; list them as TrashBlocked | The convert stamp moves with any import in the archive and misses a title edit; one cause, one line |
|
||||
| 2026-11-17 | A failed merge leaves its pair Integrating in the table, read as its previous state while the job is failed; after a project is copied, the renders moved to the kept sequence that named the source project are re-pointed to the copy and its versions (#73) | Reset the pair at failure; leave the renders | A retry must find its pair; renders must not name a project that went to the trash |
|
||||
| 2026-11-17 | Automatic photos are queued after each refresh at Background priority for Integrated pairs with AutoPhotos and no 404 mark; a failure backs off as proxy downloads do; Integrate is held on a metered connection (`UploadHold`), a merge is not (#73) | A timer of their own; hold merges too | The refresh already knows what each side lacks; a merge works only on this PC |
|
||||
| 2026-11-17 | `CopyWatch` runs local detection 30 s after the index opens and 10 s after a Scan, Rebuild, Verify, Import, Download, Convert, MergeSequences, Integrate or EmptyTrash job ends, one detection at a time, requests meanwhile giving exactly one more run; its delays are options, not a `TimeProvider` (#73) | Detect at once; a fake clock | Let the index and the job's follow-ups settle first; the test projects have no shared fake timer |
|
||||
| 2026-11-17 | `CopyEngine` takes optional dependencies (workspace guard, a refresh delegate the App routes through the sync agent, server names, the follow-up job engine, a workspace-project lister) so `Chronos.Data` holds no App type; a trash step whose photo was restored or is no longer deleted there throws `StaleCopyPlanException` (`Errors.Copies.NotThere`) and moves nothing (#73) | Reference the App's services | Data builds on Linux; the App's catch of `InvalidOperationException` still applies |
|
||||
| 2026-11-17 | The photo-trash confirmation reuses `Server.Copies.Plan.Trash` as its heading and `Archive.Delete.Action`/`Keep`; the Matches State header reuses the sync table's; the *deleted on server* and *kept here* sync tooltips reuse `Tooltips.Server.Copies.State.*`; the sample server announces `photo-lookup` and `upload-into` (#73) | New keys; a sample server without them | Same words in the same places; the screenshots show Integrate enabled |
|
||||
| 2026-11-17 | Forgetting a link on a server known only by its address (no 404 mark) deletes that remote's Candidate rows and its Linked/Integrated pair row with this local copy, and resets the local copy's probe for that server (#73) | Keep the rows | A sequence back on the server must be detected again, not hidden by a row that no link backs |
|
||||
| 2026-11-17 | A failed Integrate keeps its job id on the pair (state set back); a retry resumes only while the pair is still Integrating or carries that job; otherwise it deletes its journal and fails as a stale plan. A cancel or a stale plan clears the job id (#73) | Clear the job id on every failure | A retry must not touch a pair the user answered meanwhile, and a failed job must still be resumable |
|
||||
| 2026-11-17 | Automatic photo transfers (`SyncJobParameters.Automatic`) never create or retarget a sequence: the link and an Integrated pair with automatic photos must still hold and the server sequence must exist; else the job fails (#73) | Fall back to the ordinary upload or download | The setting moves photos between the two sides of a pair, nothing more |
|
||||
|
||||
@@ -20,6 +20,7 @@ by its `windows` job once a Windows runner is registered (`WINDOWS_RUNNER`), and
|
||||
| 8.4 Owner review 4 | Done (request and plan: `docs/requests/2026-11-06-owner-review-4.md`): released as `v0.1.0-rc.14` with owner review 1 phase 6 (the deploy guide `docs/deploy/`), then as `v1.0.0` (#23), the first stable release: R1 work board of every video made or published, the published apart from workspace work (#29); R2 the anonymous usage counts removed, nothing sent by itself (#30); R3 the archive's whole folder structure created inside the chosen archive path, desktop and server (#31); R4 the repository on Gitea in order (earlier work as closed issues #32–#54 in their milestones, the original documentation in `docs/reference/original`, `fe50b877`); R5 licensing set aside and recorded in #24. |
|
||||
| 8.5 Owner review 5 | Done (request, answers and plan: `docs/requests/2026-11-15-owner-review-5.md`; issues #64–#67, milestone v1.1.0), released as `v1.1.0`: one setup for Chronos Desktop and Chronos Uploader with the Uploader's update check (#64); the detail of mass passes (step, photo x of y, sequence n of m, rate, time left) on the desktop, the admin panel and, for the connected server's jobs, the desktop's Server section (#65); separate homes per server keyed by a stable server id, with the 1.0 workspace and cache sorted at the first start and a separate originals archive per server (#66); Chronos Desktop sharing its library on the LAN in place of Chronos Server for Windows, running on in the tray while it shares (#67). One review round, 15 findings fixed; strings in all 38 languages. Not run on the PC: the Windows-only smoke tests, `installer-test.ps1` and the release dry run (CI runs them). Follow-ups: a firewall status row, Change…/Forget on known servers, the LAN beacon announcing the server id, docs/ui DESIGN and mockups for the new screens. |
|
||||
| 8.6 Windows test of 1.1.0 | Done (#70, milestone v1.1.1), released as `v1.1.1`: the App and Core.Windows suites run whole on the development PC (5 stale screen tests brought up to date); a hands-on test of a portable 1.1.0 (import, Reorganize, sharing, a client, tray, Exit with clients); fixes: job log times in local time, the Jobs Type column, Forget in Bulgarian, the Reorganize capture. Still to do by the owner: the real 1.0 → 1.1 upgrade on this PC (UAC). |
|
||||
| 8.7 Owner review 6 | In progress (request, answers and plan: `docs/requests/2026-11-16-owner-review-6.md`; #73, milestone v1.2.0), implemented on `or6-duplicates`, not released: matches, the same time-lapse on a server and on this PC under different ids or twice on this PC, found after each sync refresh (the server's new photo lookup) and after jobs that change photos (migration 0012, `Chronos.Data.Copies`); Server › Matches with Keep apart, Link only, Unlink and the Compare dialog (Photos, Details line by line, Projects, Plan); Integrate of a local and a server sequence (job 25: photos both ways under Union by default, details as one change, projects copied across, losers to the trash only after a hash check) and the merge of two local sequences (job 26: the other to its archive's trash once every photo is verified); new photos of integrated pairs moved by themselves, *deleted there* and *deleted on server* reviewed by the user; Settings › Server › Link matches (Ask always), Integrate photos (Union), Integrate projects (Copy across); Upload all local skips suspected matches. Eight parcels, one review round (correctness, safety, conformance) with every verified finding fixed, a gap round and two verification rounds. Still to do: the 36 other languages, the PostgreSQL tests in CI, the Windows capture of the new screens against the design, the release. Follow-ups: a field-level merge of an integrated pair's settings (to ask the owner), the Import › Folder… warning, a list of second versions with Drop… in the Library and Edit. |
|
||||
| 9 Monetization | Not started: requires explicit approval (§22); the proposal is recorded in issue #24 (owner review 4, R5). |
|
||||
|
||||
## Verification (2026-10-12)
|
||||
@@ -68,6 +69,16 @@ src/Chronos.App/bin/Release/net10.0-windows/Chronos.exe --capture out/screenshot
|
||||
- Job log time (1.1.1): Jobs › expand a job: the log times match the row times (local).
|
||||
- Share this library: Settings › Server › *Share this library*, then Server › This library; connect the Uploader or
|
||||
another PC to the address shown.
|
||||
- Owner review 6 (v1.2.0, in progress): send a folder of photos to a 1.2 server with Chronos Uploader; on the desktop
|
||||
import the same folder plus a few more photos (Import › *Folder…*), give it another title and sign in. After the
|
||||
refresh Server › *Matches* lists it as *match found*; *Compare…* shows the photos only here and the differing title;
|
||||
*Integrate…* opens on Details: *All this PC*, then *Integrate*. The row reads *integrating · x of y*, then
|
||||
*integrated*, and the server holds the new photos. Add a photo on either side: it moves by itself after the next
|
||||
refresh. *Adopt folder…* a plain folder holding copies of an archived sequence's photos (no `sequence.json`):
|
||||
*Matches* lists the two as a match on this PC with
|
||||
*Merge…*; type the photo count, and the other goes to Archive › Maintenance › *Trash…*. Settings › Server › *Link
|
||||
matches* *When identical* links an identical copy by itself; *Keep apart* is not asked again. `Chronos.exe --capture`
|
||||
shows every state with sample data (`server-copies-*`, `library-copies`).
|
||||
- Import: Import › *Folder…* (any folder of photos stands in for a card) › *Import*; the sequence opens from the
|
||||
Library. Delete a sequence with *Delete…* (dry run first) and bring it back from Archive › *Trash…*.
|
||||
- Whole folder: Import › *Folder…* › Group › *Whole folder*: one plan row per file format (RAW+JPEG gives two), titled
|
||||
|
||||
@@ -0,0 +1,76 @@
|
||||
# Owner review 6 (2026-11-16)
|
||||
|
||||
## Owner's text (verbatim, Italian)
|
||||
|
||||
> Potrei avere la stessa sequenza prima caricata sul server e poi ancora presente sul computer se indico una cartella di
|
||||
> lavoro o una cartella per delle sequenze locali. In questo caso il software deve riconoscere i doppioni ed eventuali
|
||||
> differenze e farti scegliere cosa fare. Deve essere una gestione avanzata che riconosce differenze, chiede se mantenere
|
||||
> le due cartelle o integrarle e poi sincronizzarle, ecc ecc.
|
||||
|
||||
## Interpretation
|
||||
|
||||
One time-lapse can live on a Chronos Server (uploaded earlier, by this desktop or by the Uploader) and on this PC at the
|
||||
same time: in this PC's archive, in a server's originals archive (`<archive> - <server>`), in an adopted folder, or in
|
||||
the workspace. Their ids differ, so Chronos 1.1 sees two sequences. The desktop must find these copies, show how they
|
||||
differ, and let the user keep them apart or integrate them and then keep them in sync.
|
||||
|
||||
| Id | Request | Working interpretation |
|
||||
|---|---|---|
|
||||
| R1 | Recognise the same sequence (matches) | Chronos finds a *match*: two sequences that hold the same time-lapse, one on this PC and one on a server, or two in this PC's archives (this PC's archive, adopted folders, servers' originals archives). Evidence: shared photos by SHA-256 (conversions followed), by size and capture time while a side is unhashed, session keys, and an existing link. Server detection runs after each sync refresh through the server's new photo lookup (`POST /api/v1/photos/lookup`), with 1.1's rule and hints on an older server; local detection runs after the index opens and after jobs that change photos. Matches are listed under Server › *Matches*. The *Link matches* setting (default *Ask always*) decides whether Chronos links a match by itself. |
|
||||
| R2 | Show the differences | The Compare dialog shows two sequences side by side in four parts: *Photos* (each photo classed as same, same unverified, only here, only there, different, converted, deleted here, deleted there or two versions), *Details* (title, tags, rating, notes and each setting, line by line), *Projects* (each side's projects and where they go) and *Plan* (the dry run of what an Integrate or a merge will do, with its blocks). |
|
||||
| R3 | Let the user choose: keep apart, or integrate and sync | *Keep apart* is remembered (asked again only when the match grows a lot or becomes identical); *Link only* links without moving anything; *Unlink* undoes a link. *Integrate* of a local and a server sequence completes both: each side receives the photos it lacks, details are settled once, projects follow the projects choice, then the two stay linked. Two sequences on this PC are *merged* into the kept one; the other goes to its archive's trash only after every one of its photos is hash-verified in the kept one. |
|
||||
| R4 | Photos only on one side or different | The *Integrate photos* setting (default *Union*) and the dialog's photo choice: *Union* sends every photo to both sides and keeps a differing photo in both versions, listed so the user can drop one to the trash; *Choose each* preselects nothing; *This PC wins* / *Server wins* decide the differing photos for the whole sequence. Photos deleted on one side stay deleted. |
|
||||
| R5 | Projects other than Main | The *Integrate projects* setting (default *Copy across*) and the dialog's choice: each side's projects are copied to the other home with their histories, named `<name> (<PC>)` (or the server's name) on a clash. *Leave them* keeps them where they are and marks the two workspace copies as twins in Edit. A merge always copies across. Amends BRIEF §14.5. |
|
||||
| R6 | Keep them in sync afterwards | After an Integrate that left nothing out, new photos move by themselves both ways (paused on metered connections, never interrupting the user's jobs). Settings sync as today. A photo deleted on one side shows as *deleted there* and goes to the trash here only on confirmation. A server sequence that answers 404 twice reads *deleted on server*, with *Keep here*, *Upload again* and *To trash…*. |
|
||||
| R7 | A folder of local sequences; Upload all local | Such a folder is added with *Adopt folder…* (as an archive) and compared with the server and the other archives; no watched folders. *Upload all local* skips suspected matches, kept-apart sequences, sequences of a server's originals archive, sequences whose server copy was deleted and busy sequences, marks them *skipped* with the reason and leaves the matches under Matches. |
|
||||
| R8 | Track the work | Issue #73 in milestone `v1.2.0`, a board card, every commit ending with `Refs #73`. |
|
||||
|
||||
## Questions and answers
|
||||
|
||||
The questions were asked in two rounds on 2026-11-16 (the first with options and a recommendation, the second for the
|
||||
local folders and *Upload all local*). The owner answered in Italian; quoted words are his.
|
||||
|
||||
| Id | Question | Owner's answer |
|
||||
|---|---|---|
|
||||
| Q1 (R1) | When Chronos finds two copies of one sequence, does it link them by itself or ask? | "Mettere la scelta come parametro, default chiedere sempre". A setting, default *Ask always*; options *Ask always*, *When identical* (exactly the same photos) and *Half shared* (1.1's rule, its gates kept). *Keep apart* is remembered. |
|
||||
| Q2 (R3) | What does "integrate" do with the two folders? | "Completa entrambe". Two folders stay, one here and one on the server: each gets the photos it lacks, the differences are settled once, then they stay linked and in sync. Two copies on this PC are merged into one sequence; the other folder goes to the archive trash after every photo is hash-verified in the kept one. |
|
||||
| Q3 (R4) | Photos only on one side, or that differ: what is the default? | "Anche qui mettere un parametro, default unione". A setting, default *Union*; options *Union* (a differing photo kept in both versions and listed so one can go to the trash; deleted photos stay deleted), *Choose each* (nothing preselected), *One side wins* (this PC or the server, for the whole sequence). |
|
||||
| Q4 (R2) | Title, tags, rating, notes and settings that differ | "Riga per riga". In the comparison the user picks this PC's or the server's value for each difference; it is applied as one change on both sides. |
|
||||
| Q5 (R5) | Projects other than Main | "Scelta, default copiali dall'altra parte". A choice in the dialog and a default in Settings, default *Copy across*, renamed `<name> (<PC>)` on a clash; alternative *Leave them*, with the two workspace copies marked as twins in Edit. |
|
||||
| Q6 (R6) | After integrating, what stays in sync by itself? | "Foto nuove in auto". New photos move automatically both ways, paused on metered connections. Settings sync as today. A photo deleted on one side shows as "deleted there" and goes to the trash here only on confirmation. |
|
||||
| Q7 (R7) | What is "a folder of local sequences"? | "Come archivio". It is added with *Adopt folder…*, which exists, and compared with the server and the other archives. No watched folders. |
|
||||
| Q8 (R7) | *Upload all local* and suspected duplicates | "Saltale e segnalale". Skip suspected duplicates and sequences in other servers' originals archives, and leave them among the matches. |
|
||||
|
||||
## Design summary
|
||||
|
||||
- Data: migration 0012 adds `found_copies` (a pair: local↔server or local↔local, its evidence, scores, the user's
|
||||
answer, the photo policy and the 404 record) and `copy_probes` (what detection last compared, so nothing is compared
|
||||
twice while neither side moves). Every existing link with a local sequence becomes a linked pair. Code lives in
|
||||
`Chronos.Data.Copies`.
|
||||
- Server: `POST /api/v1/photos/lookup` (Read; at most 200 probes and 20,000 items) and `intoTarget` on
|
||||
`POST /api/v1/uploads`, which files a photo into the target even when another sequence of the served archive holds
|
||||
it, copied on the server (`copied` in the answer). `server/info` announces `photo-lookup` and `upload-into`. An older
|
||||
server gets detection by 1.1's rule and hints, and no Integrate.
|
||||
- Jobs: `Integrate` (stored as 25) and `MergeSequences` (26), high in the priority queue, desktop only, each with an
|
||||
atomic journal (`.chronos/journal/integrate-<job>.json`, `merge-<job>.json`) that resumes at every stage, and a plan
|
||||
fingerprint the job checks before it moves anything. A background job (an automatic transfer) never interrupts a
|
||||
running one.
|
||||
- UI: Server › *Matches* (chip, list, *Find matches*), the in-window Compare dialog (Photos, Details, Projects, Plan),
|
||||
the Replace and Merge confirmations (the merge typed by photo count), sync rows that read *match found*, *deleted on
|
||||
server*, *kept here*, *skipped*, *not sent* or *deleted there · n*, Library cards *Also elsewhere* / *Deleted there*
|
||||
with *Compare…*, the Edit picker's *Twin* chip, and three rows in Settings › Server: *Link matches*, *Integrate
|
||||
photos*, *Integrate projects*.
|
||||
- Words: the UI noun is *match* / *corrispondenza*, never *copy* / *copia*, which the photo-duplicates report owns
|
||||
(`i18n/GLOSSARY.md`: Match, Integrate, Merge sequences, Keep apart, Twin).
|
||||
|
||||
## Delivery plan
|
||||
|
||||
| Phase | Content | State | Commit |
|
||||
|---|---|---|---|
|
||||
| 1 | `v1.2.0`: R1–R7 (#73); R8 tracking. Parcels: P0 foundation (contracts, migration 0012, store, wire, trash and job hooks, keys), P1a pure comparison and rules, P1b detection and sync integration, P2 server photo lookup and uploads into a target, P3 Integrate, P4 merge of two local sequences, P5 engine composition and automatic photos, P6 the desktop surfaces; then one review round (correctness, safety, conformance) with every verified finding fixed, a gap round and two verification rounds. BRIEF §5, §6.2, §12.2, §12.3, §12.5, §12.7, §12.8, §14.3, §14.4, §14.5, §14.6, §24 and Appendix C amended; DESIGN §4 *Matches*; DECISIONS rows dated 2026-11-16 and 2026-11-17 citing #73 | in progress: implemented on `or6-duplicates`, not released; strings in en and it, the other 36 languages at the release step; the PostgreSQL tests and the Windows capture still to run | `283d04d9` … `9657c171` |
|
||||
|
||||
Follow-ups kept out of 1.2.0: a field-level three-way merge of an integrated pair's settings (settings sync as today,
|
||||
owner Q6; to be asked of the owner), the Import › Folder… warning for photos already on a server, merging two
|
||||
sequences of one server, a Library/Edit list of second versions with *Drop…*.
|
||||
|
||||
Tracking: issue #73, milestone `v1.2.0`, board card; status **in progress**.
|
||||
+28
-1
@@ -91,6 +91,33 @@ Label column left of controls: 116 px in panels, 180 px in Settings.
|
||||
Format, Length, Size, Date, State; Preset, Format and Date drop while the player is open). The player is a 420 px
|
||||
pane at the end side: Preview background, the picture or video fitted (a left-to-right island), its title and
|
||||
facts, *Show in folder* and ✕; *Cannot play here* is an EmptyState inside it.
|
||||
- **Matches** (owner review 6, #73; brief §12.7): no new colours or controls, only the kit above.
|
||||
- *Matches list*: a `Matches · n` chip after Conflicts in the Server section (warning colours while a match needs
|
||||
attention); while selected it replaces the sync table with the same row style: Sequence, This side, Other side
|
||||
(counts first, "{archive} · {n} photos"), State as glyph and word (*match found* ▲ Warning, *kept apart* ○ faint,
|
||||
*linked* ● Accent, *integrating · x of y* and *merging* ● Accent with the job's share, *integrated* ● green,
|
||||
*deleted there · n*, *deleted on server* ▲, *kept here* ○), then the state's 26 px row actions. Attention first.
|
||||
Toolbar *Find matches*; empty state "No matches found." with *Find matches*.
|
||||
- *Compare dialog*: an in-window dialog over the section's scrim, 920 px wide, at most 600 px high, its parts
|
||||
scrolling inside. Header: each side's place, photos, size and time span; a SegmentedControl *Photos · Details ·
|
||||
Projects · Plan*. Photos: the policy ComboBox, a class table of 28 px rows (glyph and class, count here, count
|
||||
there, size, a tooltip per class that follows the policy) and the selected class's virtualised photo list with
|
||||
column headings (*Bring* check box, the *Keep both / This PC's / Server's / Leave* ComboBox, *Drop…*, *To trash…*).
|
||||
Details: one row per setting, both values ellipsed (full in the tooltip) and a *This PC | Server* SegmentedControl,
|
||||
nothing preselected; *All this PC* / *All server* links above. Projects: *Copy across | Leave them* and two lists
|
||||
with the target name ("→ Vertical (STUDIO-PC)"). Plan: two columns of lines in Text, last copies first with the
|
||||
Warning glyph, *Link only* as a secondary row button, each block as a `Status.DialogError` line with at most one
|
||||
action. Two buttons: *Cancel* (safe, Esc) and *Integrate* (primary).
|
||||
- *Merge dialog*: the same dialog titled *Merge sequences*, *Kept* and *Other* in place of this PC and the server,
|
||||
the kept-sequence radio rows first in the Plan, the projects choice fixed to *Copy across* (disabled, with its
|
||||
tooltip), primary *Merge*.
|
||||
- *Confirmations*: *Replace photos?* (the losing versions under the side that loses them, last copies first) and
|
||||
*Merge sequences?* (typed photo count) as destructive `ConfirmDialog`s; Unlink and Keep apart use a toast with
|
||||
*Undo* instead.
|
||||
- *Library card status*: *Also elsewhere* or *Deleted there* as a Warning status glyph with its word, second on the
|
||||
card, in the list too; *Compare…* in the context menu and the row actions.
|
||||
- *Edit picker twin*: a muted *Twin* chip right after the project name of a Workspace row; its tooltip names the
|
||||
other home and project.
|
||||
- **Crop overlay** (preview, Camera step; owner review 1, R5): the box is drawn over the whole view frame (oriented,
|
||||
straightened) and is always locked to the output aspect. States (tiles under the Camera screen in `Editor.html`):
|
||||
- *Shown*: Crop mask on, any step: Scrim (#99000000 dark, #66000000 light) outside, 1 px TextMuted outline.
|
||||
@@ -183,7 +210,7 @@ from the SVG geometry (no raster assets checked in as sources). Badges only at
|
||||
| `Import.html` | §12.4 / §13 | card profile, sessions, plan, verification, after-import actions |
|
||||
| `Archive.html` | §12.5 | tree, mass operations, stats, verify/rebuild, maintenance |
|
||||
| `Jobs.html` | §12.6 | filters, queue order, expandable log, retry/open/folder; a `Queue · Scheduled` segmented control first in the toolbar (owner review 2, R10): Scheduled is a table (on switch, name, action, when, next run, last result, Run now · Edit · Reset or Delete), the selected schedule's last runs under it (Show in queue), New schedule at the toolbar's end and the editor as an in-window dialog; jobs a schedule queued carry an Accent `Scheduled` pill after their target |
|
||||
| `Server.html` | §12.7 / §14 | connection with TOFU fingerprint, account and quota, render node, sync table, conflicts |
|
||||
| `Server.html` | §12.7 / §14 | connection with TOFU fingerprint, account and quota, render node, sync table, conflicts; the Matches list and the Compare/merge dialog (owner review 6) have no mockup: built from §4 *Matches* and checked against the `server-copies-*` captures |
|
||||
| `Settings.html` | §12.8 | section list (About last, §12.9), Rendering section, encoder table, self-test |
|
||||
| `Welcome.html` | §12.1 | first run: local archive / adopt folder / connect; Continue; card toast |
|
||||
| `Admin.html` | §14.7 | dashboard; sidebar: pages from the top, Settings docked at its foot above the account, no About (the last group of Settings) |
|
||||
|
||||
Reference in new issue
Block a user