docs: BRIEF, DECISIONS, CHANGELOG and STATUS for owner review 2 phase 4b
The docs now describe mass conversion after import as the code at 48a0ce3e does it:
Replace or New sequence chosen at every run, the dry run and the convert job of
exactly the confirmed photos, the scene-referred linear DNG, the replaced trash
entries with their Undo and emptying, and sync and ingest counting every encoding
of a photo as one. Four earlier DECISIONS rows are marked superseded in part.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit c746fe689c7bf16a3b5c28ea7694d91cf423f4a9)
This commit is contained in:
1 parent
c3611a350d
commit
f972174c7f
6 files changed
+472
-79
No files matched your search
+26
-19
@@ -8,7 +8,7 @@ Companion to `docs/BRIEF.md` (scope, behaviour) and `docs/ui/DESIGN.md` (looks).
|
||||
| Project | TFM | Purpose |
|
||||
|---|---|---|
|
||||
| `src/Chronos.Core` | net10.0 | Engine shared by every program: metadata, codecs, imaging, analysis, advisor, motion, render, video containers and managed encoders, archive format, naming, import planning, packaging, localization runtime, diagnostics, brand mark |
|
||||
| `src/Chronos.Core.Windows` | net10.0-windows | WIC decoders and codec inventory, Media Foundation encoders, DXGI adapters, removable devices, DPAPI, shell launcher, window chrome, power (P/Invoke/COM only) |
|
||||
| `src/Chronos.Core.Windows` | net10.0-windows | WIC decoders and codec inventory, Media Foundation encoders, DXGI adapters, removable devices and volume free space, DPAPI, shell launcher, window chrome, power (P/Invoke/COM only) |
|
||||
| `src/Chronos.Data` | net10.0 | `IDatabase`, SQLite binding, PostgreSQL wire client, migrations, repositories, the job engine, the archive engine (`Archiving`), the analysis/render engine (`Processing`) and the client sync engine (`Sync`) |
|
||||
| `src/Chronos.Protocol` | net10.0 | API v1 DTOs, source-generated JSON context, typed `ChronosClient` with certificate pinning and bandwidth limiting |
|
||||
| `src/Chronos.Server` | net10.0 (Web SDK) | ASP.NET Core minimal API, auth, uploads, sync, jobs, render nodes, events, embedded admin panel, Windows service host |
|
||||
@@ -29,9 +29,9 @@ Dependencies point one way: `Core` ← `Core.Windows`, `Data`, `Protocol` ← `S
|
||||
|
||||
| Folder / namespace | Content |
|
||||
|---|---|
|
||||
| `Imaging` (+ `Decoders`, `Geometry`, `Thumbnails`) | `ImageBuffer` (planar float, linear light), `IImageDecoderProvider`, `DecoderFactory` (decode tiers: native → embedded preview; `ImageDecoder.Probe` names a file's tier without decoding it; `DecodeRequest.PreferPreview` takes an adequate RAW preview by choice for analyses and previews, `DecodedImage.ByChoice`), `ManagedDecoderProvider`, `FrameWindow` (read-ahead, memory budget, float32 spill), resampler, thumbnail cache |
|
||||
| `Metadata` (+ `Tiff`, `Jpeg`, `Bmff`, `Raf`, `Riff`, `Png`, `Xmp`, `MakerNotes`) | Signature sniffing, Exif/GPS/XMP/MakerNotes, ISO-BMFF (HEIF, CR3), `MetadataReader`, `MetadataBuilder` (all fallback chains), `ExifWriter` |
|
||||
| `Codecs` (`Jpeg`, `Png`, `Tiff`, `Dng`, `Raw`, `Gif`, `Apng`, `Ico`) | Pure managed codecs; native RAW development (DNG, CR2, NEF, ARW, PEF, RAF) |
|
||||
| `Imaging` (+ `Decoders`, `Geometry`, `Thumbnails`) | `ImageBuffer` (planar float, linear light), `IImageDecoderProvider` (`DevelopsRawAt8Bits`: true for WIC's Raw Image Extension, which a conversion's 16-bit targets never read RAWs through), `DecoderFactory` (decode tiers: native → embedded preview; `ImageDecoder.Probe` names a file's tier without decoding it; `DecodeRequest.PreferPreview` takes an adequate RAW preview by choice for analyses and previews, `DecodedImage.ByChoice`), `ManagedDecoderProvider` (`ReadsHeaders`: a conversion's probes read JPEG, PNG and TIFF headers and refuse what the decoders would), `FrameWindow` (read-ahead, memory budget, float32 spill), resampler, thumbnail cache |
|
||||
| `Metadata` (+ `Tiff`, `Jpeg`, `Bmff`, `Raf`, `Riff`, `Png`, `Xmp`, `MakerNotes`) | Signature sniffing, Exif/GPS/XMP/MakerNotes, ISO-BMFF (HEIF, CR3), `MetadataReader`, `MetadataBuilder` (all fallback chains), `ExifWriter` (proxies, exports and converted photos; exposure program, metering mode, flash and white balance when known) |
|
||||
| `Codecs` (`Jpeg`, `Png`, `Tiff`, `Dng`, `Raw`, `Gif`, `Apng`, `Ico`, `Icc`) | Pure managed codecs; native RAW development (DNG, CR2, NEF, ARW, PEF, RAF); header reads that refuse what a decode would (`JpegDecoder.ReadDecodableInfo`, `PngDecoder.MaxPixels`, `TiffImageReader.ReadInfo`; the TIFF reader refuses CMYK, CIELab, palette and other samples it does not render); ICC profiles written into JPEG (APP2) and TIFF (tag 34675); `LinearDngWriter` (exports: clipped linear sRGB; `LinearDngOptions.SceneReferred` for a conversion: linear ProPhoto primaries, up to `MaxHeadroomStops` (4) of headroom in BaselineExposure, matrices that read back as written); `Icc` (`IccProfile`: ICC parser and writer, matrix/TRC and gray curves, sRGB told by the numbers, colorants that convert nothing dropped, the in-house Adobe RGB (1998)-compatible and Display P3 profiles; `SourceColor`: the colour space a photo's headers record and whether its samples are linear) |
|
||||
| `Analysis` (+ `Deep`) | Luminance statistics, deflicker, regions, holy grail, white balance, colour temperature, light analysis, streaming deep analysis with checkpoints |
|
||||
| `Advice` | `Advisor`: recommendations with localisable reasons, apply/optimise, sequence presets |
|
||||
| `Motion` | FFT, phase correlation, pyramids, optical flow, motion blur, stabiliser, virtual camera, interpolation, stacking |
|
||||
@@ -42,7 +42,7 @@ Dependencies point one way: `Core` ← `Core.Windows`, `Data`, `Protocol` ← `S
|
||||
| `Video` (+ `Mp4`, `Avi`, `Bitstream`, `Yuv`, `Managed`) | `IVideoEncoderProvider`, MP4 muxer and inspector, AVI-MJPEG, NV12/P010, managed encoders (MJPEG-AVI, GIF, APNG, image sequences) |
|
||||
| `Archiving` | Archive layout and paths, sidecars (`sequence.json`, `project.json`), scanner, index snapshot, leases, thumbnail packs, verify, adopt, rename plans (`RenamePlanner`: folder, title and file templates, `RenameTemplates`, the plan's fingerprint, which pins every file rename by its digest and not the frames version; `FileRenames`: a sequence's new file names; `FileRenameJournal`: two-phase renames through temporary names, `.chronos/rename-files.json`, a recovery safe to run again from wherever it stopped, a new name taken meanwhile sending that photo and its companions back together to their old names or a free `_2`, those that took their new names already with them; `FrameCompanions`: the XMP files that follow a photo, one rule for the trash and Reorganize, matched whatever their case and each folder listed once by `FrameCompanions.Index`) |
|
||||
| `Import` | Card scan, session detection, import plan (photos named through `FrameNaming` with the camera and lens of their session's first photo), hash-verified copy, card eraser (re-hash before delete) |
|
||||
| `Conversion` | Mass conversion after import (owner review 2, R7): `ConvertOptions` (target JPEG 4:4:4 / TIFF-16 / linear DNG, JPEG quality, the converted name: the archive's file template with the frame's `FrameNaming` context in its sequence, as filing names it, `{ext}` the target's), `FrameConverter` (native-tier decode only, in-house encoders, Exif from the sidecar and the original via `ExifWriter`, hashed as made, written atomically, verified: read back, metadata again, decoded by the server's decoders), `ConvertPlanner` (per sequence the frames converted and skipped with `ConvertSkip`, size estimates per pixel, `ConvertPlan` with its space and fingerprint) |
|
||||
| `Conversion` | Mass conversion after import (owner review 2, R7): `ConvertOptions` (target JPEG 4:4:4 / TIFF-16 / linear DNG, the archival one, `ConvertMode` Replace or New sequence, JPEG quality and the quality that counts, the converted name: the archive's file template with the frame's `FrameNaming` context in its sequence, as filing names it, `{ext}` the target's), `FrameConverter` (`Decoders`: the conversion's chain, the managed provider first with its header probes, WIC after it, no RAW at 8 bits for a 16-bit target; native-tier decode only; `Treatment`: what becomes of the colour space, carried, encoded with the profile's curves, converted or refused; in-house encoders, Exif from the sidecar and the original via `ExifWriter`, hashed as made, written atomically, verified: read back, metadata again, decoded by the server's decoders; `ConversionException` and its `ConversionFailure`, `FailureText`: the job log's sentence by cause), `ConvertPlanner` (per sequence the frames converted and skipped with `ConvertSkip`, each file probed with the conversion's decoders whatever tier was recorded, 8 at a time; `TooLarge`: what the target holds and the server's decoders read back; size estimates per pixel; `ConvertSequencePlan.Digest`, the photos converted with their content; `ConvertPlan` with its space and fingerprint) |
|
||||
| `Naming` | Folder/file templates and tokens (folder levels scans skip escaped with `_`; `ExpandText` for titles; `ExpandFile` shortens a long file name before its `.{ext}`); `FrameNaming` (the naming context and unique file name of a frame, shared by import, upload, Reorganize and conversion: the sequence's camera and lens, the first frame for folders; `UniqueNames`: `_2`, `_3`… in linear time); `TemplateRules` (what every place a template is typed or sent refuses, the archive engine's new or changed templates included: a folder scans skip, a lost extension, names that repeat) |
|
||||
| `Model` | Domain entities and enums (§5) shared by Data, Server and clients |
|
||||
| `Packaging` | TPK1 installer payload writer/reader, staged install transaction |
|
||||
@@ -55,13 +55,13 @@ 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), `RenderRepository.RebaseFolderAsync` (the export paths that follow a moved folder); `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) |
|
||||
| `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); `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) |
|
||||
| `Scheduling` | `Scheduler` (one per host: seeds the host's system schedules, claims due runs by compare-and-set, catch-up, clock changes, create/edit/reset/delete/run now as API v1 DTOs), `ScheduleRecurrence` (the in-house `every:`/`daily:`/`weekly:`/`monthly:` form, wall-clock times across DST), `ScheduleActions` (action names, parameters, availability, the archive jobs a run queues), `IScheduleHost` and `SystemSchedule` (what the server and the desktop supply), `ScheduleOutcome`, `ScheduleMapping` (model ↔ DTO) |
|
||||
| `Housekeeping` | `BackupJobHandler`, `CleanupJobHandler`, `ICleanupStep` with the shared steps (`CleanupSteps`: job history, audit log, trash report that never deletes); hosts add their own steps through `ArchiveServiceOptions.CleanupSteps` |
|
||||
| `Archiving` | `ArchiveService` (create/adopt/open, archive settings written to `archive.json` then the index, `ArchiveSettings.CheckTemplates` and `TemplateRuleException` holding a template given anew to the template rules; `UnderLeaseAsync`: a write under a sequence's lease with its row read under it), `ArchiveIndexer` (scan, rebuild; a sequence found in another folder takes its exports' paths along), `ArchiveIngest` (uploads and imports, named through `FrameNaming`), `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`, `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), `FrameTrash` (photos of a sequence into `trash/photos` with a dry run, a journal that undoes an interrupted deletion whose entry stays unlisted until its sidecar is written, tombstones (a photo never hashed is hashed as it goes; one whose original is missing goes without a file or tombstone; a frame that stays and may be a twin is hashed, its hash kept), positions parked and placed back, proxies and thumbnails moved to follow their frames; `FrameTrash.Restore`: restore re-hashes each file and says why each kept photo stayed (`KeptReason`), under a journal of its own into the sequence that another writer settles only under the entry's lease, into a new sequence through the ingest when theirs is gone, each original staged inside its own entry and the record rewritten after each photo filed; a replaced entry swaps back while its converted frames are unchanged; `FrameTrash.Replace`: the files of frames swapped in place, same ids and indices, the old files into one `Replaced` entry with their replacements' hashes and a copy of `analysis.json`, tombstones aliasing old content to new, under `.chronos/replace.pending.json`, which the next writer undoes or completes), `MassConverter` (conversion's dry run with busy, offline and unreadable sequences and the space against `ArchiveServiceOptions.FreeSpace`; the job's stage A converts into `staging/convert-<job>/` with `OrderedWork`, each staged file appended to `journal/convert-<job>.staged`; stage B per sequence, all or nothing: replace through `FrameTrash.ReplaceAsync` (the sequence's folder read again under its lease, as every writer does), or a new sequence through the ingest with the source's tags, rating, notes and project; each sequence replaced or made told as it completes), job handlers |
|
||||
| `Archiving` | `ArchiveService` (create/adopt/open, archive settings written to `archive.json` then the index, `ArchiveSettings.CheckTemplates` and `TemplateRuleException` holding a template given anew to the template rules; `UnderLeaseAsync`: a write under a sequence's lease with its row read under it), `ArchiveIndexer` (scan, rebuild; a sequence found in another folder takes its exports' paths along), `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 walking the archive) through their replaced tombstones, `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), `FrameTrash` (photos of a sequence into `trash/photos` with a dry run, a journal that undoes an interrupted deletion whose entry stays unlisted until its sidecar is written, tombstones (a photo never hashed is hashed as it goes; one whose original is missing goes without a file or tombstone; a frame that stays and may be a twin is hashed, its hash kept), positions parked and placed back, proxies and thumbnails moved to follow their frames; `FrameTrash.Restore`: restore re-hashes each file and says why each kept photo stayed (`KeptReason`), under a journal of its own into the sequence that another writer settles only under the entry's lease, into a new sequence through the ingest when theirs is gone, each original staged inside its own entry and the record rewritten after each photo filed; a replaced entry swaps back while its converted frames are unchanged (`SwapBackAsync`); `FrameTrash.Replace`: the files of frames swapped in place, same ids and indices, the old files into one `Replaced` entry with their replacements' hashes, a copy of `analysis.json` and the job's id, the incoming files named never onto a file there, tombstones aliasing old content to new, under `.chronos/replace.pending.json` (its phase Line truncated
|
||||
| `Processing` | `ProcessingService`, `SequenceAnalyser`, `DeepReports` (a saved deep report while it still describes the frames), `SequenceRender`, `ProjectStore`, `ProjectBundles` (a `.chronos` file for a sequence, and the sequence a file names), `RenderNodeClient`, job handlers |
|
||||
| `Sync` | `SyncService` (sync table of one server: compare, link by content, settle conflicts, enqueue transfers), `SyncRules` (status, settings merge and differences, no I/O), `SyncTombstones` (photos either side removed are not offered back, a replaced photo counts as its replacement), `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), `SyncAgent` (background comparison, server events, backoff, offline proxies), `ProxyCache` and `RemoteSequence` (server sequences opened with proxies), `ISyncRemote` (the server calls; `ChronosSyncRemote` over `ChronosClient`) |
|
||||
| `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), `ProxyCache` and `RemoteSequence` (server sequences opened with proxies), `ISyncRemote` (the server calls; `ChronosSyncRemote` over `ChronosClient`) |
|
||||
|
||||
### 2.3 Chronos.App areas
|
||||
|
||||
@@ -69,13 +69,13 @@ Dependencies point one way: `Core` ← `Core.Windows`, `Data`, `Protocol` ← `S
|
||||
|---|---|
|
||||
| `Shell` | `MainWindow` (rail and its shortcuts, taskbar progress), `ShellViewModel` (rail, sections, first run), `OsNotifications` (toasts as Windows notifications while the window is minimised or in the background), dialogs, `ErrorText` (the sentence of an error toast), `ScreenCapture` (`--capture` scenes), `SectionTemplates.xaml` (view model → view) |
|
||||
| `Sections` | One `XxxView.xaml` + `XxxViewModel` per screen: Welcome, Library, Sequence (the Edit section: the editor, and `SequencePickerView` choosing the sequence in place), Import, Archive, Jobs (two tabs, Queue and Scheduled: `SchedulesView` shows `Jobs/SchedulesViewModel`), Server, Settings (its last page is About) |
|
||||
| `Library` | Filter, facets, pager, timeline, saved views, quick and mass actions, remote cards and thumbnails, thumbnail cache, list export |
|
||||
| `Library` | Filter, facets, pager, timeline, saved views, quick and mass actions (`MassActions`: Reorganize and Convert for the sequences of one archive), remote cards and thumbnails, thumbnail cache, list export |
|
||||
| `Editor` | `EditorSession` (project, undo/redo, saving, merges), `ISequenceSource` (`LocalSequenceSource`, `RemoteSequenceSource`), the steps of the Edit path (`EditPath`: their order, each step's state, the step of each finding, the memory of the step shown; tabs Analysis, Frames, Exposure, Motion, Camera, Time, Stack, Export), `PreviewRenderer`, `ExportPlanner`, `ExportSync`, `SavedCopies`, `SequenceJobs`, `ProjectFiles` (save and open `.chronos` project files) |
|
||||
| `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, Apply behind a typed confirmation for Replace queues the `convert` job of that plan; `ConvertPlans`: the plan as rows, a summary, the space line and the Replace confirmation; `ConvertUndo`: the Undo of a finished Replace, which restores its `Replaced` trash entries), retag, delete and trash dialogs (`SequenceDeletion`, `DeletePlans`, `TrashEmptyPlans`: Empty… behind a dry run and a typed confirmation), `ArchiveFailures` |
|
||||
| `Archive` | `CurrentArchive`, `ArchiveTree`, figures for the charts, maintenance reports, Reorganize (`ReorganizeDialogViewModel`: folder, file and title templates each with its switch, the dry run, Apply queues the `move` job of that plan; `ReorganizePlans`: each template's check, the plan as rows and a summary; `ReorganizeOffer`: per archive, the templates Settings › Archive's toast offers, joined while that archive's toast is up), Convert (`ConvertDialogViewModel`: format, JPEG quality and a mode chosen at every run, the dry run made once per format and quality, Apply behind the mode's confirmation queues the `convert` job of that plan through `MassConverter.QueueAsync`; `ConvertPlans`: the plan as rows in the mode's words, a summary, the space line, the Replace confirmation that types the number of photos and the New sequence one that counts the photos not copied; `ConvertUndo`: the Undo the Jobs screen's toast offers when Replace conversions end, which restores the `Replaced` trash entries their jobs made, by the job's id), retag, delete and trash dialogs (`SequenceDeletion`, `DeletePlans`, `TrashEmptyPlans`: Empty… behind a dry run and a typed confirmation, every entry whose conversion was deleted named first), `ArchiveFailures` |
|
||||
| `Server` | `ServerSession`, `ConnectFlow` (trust on first use), `SyncHost` (sync engine, agent, metered hold, editor connections, Export Sync), sync table, `RemoteSequenceApi` |
|
||||
| `Jobs`, `Settings`, `About` | Job list and buffering, `JobNotices` (which job endings raise a toast; `JobEndings` lets a batch speak once); the schedules of Jobs › Scheduled (`DesktopScheduleHost`: the desktop's `IScheduleHost` and its system schedules `archive-scan`, `index-backup`, `housekeeping`; `CacheTrimStep`, the host's clean-up step; `SchedulesViewModel`, `ScheduleRowViewModel`, `ScheduleEditorViewModel` and `ScheduleDialogs.xaml`, the in-window editor; `ScheduleText`); settings rows (`LogSettingsRows`: Advanced's log rows), encoder and format inventories, `ProcessingTuning` (Settings › Rendering and Analysis applied to each job: parallelism, memory budget, quality), `InterfacePriority`, language catalog, naming preview; `AboutViewModel` (owned by the shell, not a section: Settings › About, the update notice of Settings › Updates and the update check on start), update check and download |
|
||||
| `Infrastructure` | `AppServices` (composition root; `SequenceReorganized`, raised after each Reorganize step, reloads an editor open on that sequence), `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 |
|
||||
| `Jobs`, `Settings`, `About` | Job list and buffering, `JobNotices` (which job endings raise a toast, conversions among them; `JobEndings` lets a batch speak once); the schedules of Jobs › Scheduled (`DesktopScheduleHost`: the desktop's `IScheduleHost` and its system schedules `archive-scan`, `index-backup`, `housekeeping`; `CacheTrimStep`, the host's clean-up step; `SchedulesViewModel`, `ScheduleRowViewModel`, `ScheduleEditorViewModel` and `ScheduleDialogs.xaml`, the in-window editor; `ScheduleText`); settings rows (`LogSettingsRows`: Advanced's log rows), encoder and format inventories, `ProcessingTuning` (Settings › Rendering and Analysis applied to each job: parallelism, memory budget, quality), `InterfacePriority`, language catalog, naming preview; `AboutViewModel` (owned by the shell, not a section: Settings › About, the update notice of Settings › Updates and the update check on start), update check and download |
|
||||
| `Infrastructure` | `AppServices` (composition root; `SequenceReorganized`, raised after each Reorganize step and each sequence a conversion replaced or made, reloads an editor open on that sequence; the archive engine's free space from `VolumeInfo.FreeBytesAt`), `AppSettings`, `AppLogging` (Settings › Advanced › Logs applied to the log files from their first line, a launch that only hands over included, and at every save), `AppEnvironment` (installed or portable), `AppClock` (today's date, frozen by `--capture`), `StartWithWindows` (this copy's sign-in entry), `UiLanguage`, `LiveRegion`, `RenderNodeHost`, `DiagnosticsBundle`, `ShellActions` (BRIEF §8.6), `SingleInstance` (one Chronos per data folder; a later launch hands its file over a named pipe, or waits for a closing one to exit and starts in its place), device monitor |
|
||||
| `DesignTime` | `SampleData`: the archive, jobs and server the screenshots and smoke tests run on, dated from the fixed `SampleData.Now` |
|
||||
|
||||
### 2.4 Chronos.Ui and Chronos.Server
|
||||
@@ -86,17 +86,17 @@ Dependencies point one way: `Core` ← `Core.Windows`, `Data`, `Protocol` ← `S
|
||||
| `Ui/Controls` | `ChronosWindow` (chrome, language direction), `NavRail`, `JobBar`, `ToastHost` (`Toast.Closed` once a toast leaves the screen), `Field` (placeholder, icon, error), `Chip`, `AutoSlider`, `StatusGlyph`, `EmptyState`, `Icon`, `Bidi` (right-to-left rules), `Motion` (animations off for screenshots) |
|
||||
| `Ui/Interop` | DWM calls of the window chrome; `TrayIcon` (`Shell_NotifyIconW`: the Uploader's tray, the client's Windows notifications) |
|
||||
| `Ui/Visuals` | `DrawingElement` (hover readout, item keyboard and activation) and its charts (`BarChart`, `SeriesChart`, `StackedBar`, `HeatmapStrip`, `TimelineBands`), `Filmstrip`, `PreviewViewport`, `CurveEditor`, `SequenceCard`, `VirtualizingWrapPanel`, `SegmentedControl`, `SplitButton` |
|
||||
| `Server/Api`, `Server/Events` | Endpoint groups (`XxxEndpoints.Map`; `ScheduleEndpoints`: `/api/v1/schedules`; `LibraryEndpoints`: the Library filters' facets, sequence thumbnail, photo delete, bulk delete/retag/jobs; `TrashEndpoints`: list, restore, empty; `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, kept a few minutes while what it reads from the index stays (its `PlanKey`), for the same dry run and its confirmation), API errors, the WebSocket `EventHub` |
|
||||
| `Server/Api`, `Server/Events` | Endpoint groups (`XxxEndpoints.Map`; `ScheduleEndpoints`: `/api/v1/schedules`; `LibraryEndpoints`: the Library filters' facets, sequence thumbnail, photo delete, bulk delete/retag/jobs; `TrashEndpoints`: list, restore, empty (`conversionDeleted` in its dry run); `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`), 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; `FolderMovedException`, 503 `folder_moved`, when the sequence is not in it); `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, monitor and availability |
|
||||
| `Server/Hosting`, `Server/Admin/web` | `ServerHost`, `ServerLogging` (console and file levels the logging filters read at every line, the file sink's limits, the engine's level; applied again when Settings › Logs is saved), certificates, discovery beacon, embedded static files (`EmbeddedStaticFiles`: `no-cache` and a content ETag, so an upgrade never mixes old and new modules), Windows service (start and stop failures in the Application event log); the admin panel (ES modules, one per page; `schedules.js` is the Jobs page's Scheduled tab; the Library's views in `pages/library/`: `sequence.js` a sequence and its photo viewer, `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: format, JPEG quality and a mode chosen at every run (Replace or New sequence, never preselected), a debounced dry run of `POST /archive/convert` per sequence (photos converted, left as they are and why, blocked, size before and after, the space line), Apply that confirms Replace by a typed word and sends the shown plan's fingerprint back) |
|
||||
| `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; `FolderMovedException`, 503 `folder_moved`, when the sequence is not in it); `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, monitor and availability |
|
||||
| `Server/Hosting`, `Server/Admin/web` | `ServerHost`, `ServerLogging` (console and file levels the logging filters read at every line, the file sink's limits, the engine's level; applied again when Settings › Logs is saved), certificates, discovery beacon, embedded static files (`EmbeddedStaticFiles`: `no-cache` and a content ETag, so an upgrade never mixes old and new modules), Windows service (start and stop failures in the Application event log); the admin panel (ES modules, one per page; `schedules.js` is the Jobs page's Scheduled tab; the Library's views in `pages/library/`: `sequence.js` a sequence and its photo viewer, `trash.js` the archive's trash, `shared.js` cards, selection, grid keyboard and the retry of thumbnails a finished job may have built; `upload.js` the upload dialog the Library opens on demand, hashing in the module worker `hash-worker.js` with the in-house incremental SHA-256 of `sha256.js`, self-tested before its first use, and sending the capture time `capture-time.js` reads: the Exif DateTimeOriginal of a JPEG or TIFF-based file, else the file's time; `reorganize.js` the Reorganize dialog of the Library's selection and of the Archive page's save toast: template switches and fields, a live dry run of `POST /archive/reorganize` one request at a time, Apply that sends the shown plan's fingerprint back; `convert.js` the Convert dialog of the Library's selection (`planTarget` in `library.js`, shared with Reorganize: the ids, at most 1,000, or `all`): format, JPEG quality and a mode chosen at every run (Replace or New sequence, never preselected), a debounced dry run of `POST /archive/convert` one request at a time, asked in Replace's words until a mode is chosen and again while the server is still making it (a proxy's cut-off, `plan_dropped`), per sequence photos converted, left as they are or not copied and why, blocked, size before and after, the space line; Apply that confirms Replace by a typed word and New sequence with the photos not copied, asks the dry run again and sends the shown plan's fingerprint back, never twice after no answer; `pages/library/trash.js` gives replaced entries their own Restore and lists those whose conversion was deleted first; `audit.js` reads `archive_converted` as a sentence) |
|
||||
|
||||
### 2.5 Hosts
|
||||
|
||||
| Host | Composition root | What it runs |
|
||||
|---|---|---|
|
||||
| Chronos (desktop) | `App/Infrastructure/AppServices` | SQLite index in `%LOCALAPPDATA%\Chronos` (or `.\data` when portable, unless the copy is in a OneDrive folder); `ArchiveService` with WIC first, then managed decoders; `ProcessingService` with Media Foundation, then managed encoders; one `JobEngine` with the handlers of both; thumbnails; `ServerSession`; `SyncHost` while signed in (sync engine and agent, upload and download handlers, metered hold, editors of server sequences); the render node while opted in and signed in; update check and download (`About/UpdateCheck`, `About/UpdateDownload`, `About/UpdateFlow`: the setup, or the portable zip for a portable copy, verified against `SHA256SUMS`, resumable, cancellable, failing after 60 s without data); diagnostics bundle; the `Scheduler` on `DesktopScheduleHost`, started once the archive was reopened (an unplugged one is looked for every minute), which then runs the archive scan once (again when an unplugged archive is back), and whose system schedules replaced the rescan timer, the daily backup loop and the job-history purge (scans follow Settings › Analysis › After a scan at every run); the restore staged in Settings › Advanced (`DatabaseBackups`) |
|
||||
| Chronos Server | `Server/Hosting/ServerHost.Build` | Options from `server.json` + `CHRONOS_*`; PostgreSQL (or SQLite on Windows); `ArchiveModule` then `ProcessingModule` register job handler providers; `JobEngineHost` (renders only managed formats and MP4 jobs no render node can take, BRIEF §14.7); `RenderNodeService`/`RenderNodeMonitor`; `UploadService`; `VolumeSpace` (free space of the archive, the space path and `/data`, file system and mount from `/proc/self/mountinfo`; tests replace it); `EventHub` (WebSocket); embedded admin panel; LAN discovery beacon; Windows service host; `SchedulerHost` with the system schedules `archive-scan` (every 10 minutes, also once at start), `upload-cleanup` (every 6 hours), `index-backup` (SQLite only, 03:00), `housekeeping` (job history, 04:00) and `audit-cleanup` (04:30; Settings › Logs shows and sets its age limit, 0 while it is off; seeded and reset from `AuditRetentionDays`, 0 by default: off, the audit log kept; `CHRONOS_AUDIT_RETENTION_DAYS` fixes it before the first pass), no other timer queues work (a 10-minute timer only reads archive.json again) |
|
||||
| Chronos (desktop) | `App/Infrastructure/AppServices` | SQLite index in `%LOCALAPPDATA%\Chronos` (or `.\data` when portable, unless the copy is in a OneDrive folder); `ArchiveService` with WIC first, then managed decoders (a conversion orders its own chain, the managed decoders first), its free space measured by Windows (`VolumeInfo.FreeBytesAt`, UNC shares included); `ProcessingService` with Media Foundation, then managed encoders; one `JobEngine` with the handlers of both; thumbnails; `ServerSession`; `SyncHost` while signed in (sync engine and agent, upload and download handlers, metered hold, editors of server sequences); the render node while opted in and signed in; update check and download (`About/UpdateCheck`, `About/UpdateDownload`, `About/UpdateFlow`: the setup, or the portable zip for a portable copy, verified against `SHA256SUMS`, resumable, cancellable, failing after 60 s without data); diagnostics bundle; the `Scheduler` on `DesktopScheduleHost`, started once the archive was reopened (an unplugged one is looked for every minute), which then runs the archive scan once (again when an unplugged archive is back), and whose system schedules replaced the rescan timer, the daily backup loop and the job-history purge (scans follow Settings › Analysis › After a scan at every run); the restore staged in Settings › Advanced (`DatabaseBackups`) |
|
||||
| Chronos Server | `Server/Hosting/ServerHost.Build` | Options from `server.json` + `CHRONOS_*`; PostgreSQL (or SQLite on Windows); `ArchiveModule` then `ProcessingModule` register job handler providers; `JobEngineHost` (renders only managed formats and MP4 jobs no render node can take, BRIEF §14.7); `RenderNodeService`/`RenderNodeMonitor`; `UploadService`; `VolumeSpace` (free space of the archive, the space path and `/data`, file system and mount from `/proc/self/mountinfo`; `WritableFree`, what a conversion counts on; tests replace it); `EventHub` (WebSocket); embedded admin panel; LAN discovery beacon; Windows service host; `SchedulerHost` with the system schedules `archive-scan` (every 10 minutes, also once at start), `upload-cleanup` (every 6 hours), `index-backup` (SQLite only, 03:00), `housekeeping` (job history, 04:00) and `audit-cleanup` (04:30; Settings › Logs shows and sets its age limit, 0 while it is off; seeded and reset from `AuditRetentionDays`, 0 by default: off, the audit log kept; `CHRONOS_AUDIT_RETENTION_DAYS` fixes it before the first pass), no other timer queues work (a 10-minute timer only reads archive.json again) |
|
||||
| Chronos Uploader | `Uploader/App.xaml.cs` | `ChronosClient`, persisted queue, watch folders; no database |
|
||||
| Chronos Setup | `Setup/Program` | TPK1 payload extraction, registry, shortcuts, file types named in setup's language, silent mode, uninstaller; only what starts a program its log or payload lists is changed: Windows services of those programs stopped once the programs have closed, started again (also after a failure) or deleted through the Service Control Manager (an elevated `/SERVICES … /NAMES` step when needed), sign-in entries of those programs moved to the program an upgrade renamed or removed, shared shortcuts handed to the product that keeps the program; the Server only for all users inside Program Files; "Remove my data" limited to the programs no other installed product uses |
|
||||
|
||||
@@ -117,7 +117,7 @@ Dependencies point one way: `Core` ← `Core.Windows`, `Data`, `Protocol` ← `S
|
||||
| `Cleanup` | `Housekeeping/CleanupJobHandler` (shared steps, plus the host's from `ArchiveServiceOptions.CleanupSteps`) | yes | yes |
|
||||
| `EmptyTrash` | `Archiving/Jobs/EmptyTrashJobHandler` (erases exactly a confirmed plan's trash entries; refuses a stale fingerprint) | yes | yes |
|
||||
| `Move` | `Archiving/Jobs/MoveJobHandler` (Reorganize, `MoveJobParameters`: the templates, the sequences and the confirmed fingerprint; plans again from the templates, applies the plan only while it is the one confirmed, holds it when paused, cancelled or failed, keeps it while the archive is offline, tells each sequence changed as its step completes) | yes | yes |
|
||||
| `Convert` | `Archiving/Jobs/ConvertJobHandler` (mass conversion through `MassConverter`: targets are the sequences; plans again, refuses short space, converts each sequence all or nothing, resumes from its journal, queues the passes the frames need again) | yes | yes (formats the server cannot decode natively are skipped: convert on a PC) |
|
||||
| `Convert` | `Archiving/Jobs/ConvertJobHandler` (mass conversion through `MassConverter`, `ConvertJobParameters`: the target, quality and mode, the sequences with their frames version, the digest and ids of the photos confirmed, and the fingerprint; targets are the sequences; settles what a crash left, refuses short space, converts each sequence all or nothing, the confirmed photos alone, resumes from its journal, tells each sequence `converted` or `created` and queues the passes it needs as it completes) | yes | yes (formats and files the server cannot decode natively are skipped: convert on a PC) |
|
||||
| `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)
|
||||
@@ -163,6 +163,13 @@ folder gone or holding another sequence (`SequenceFolders.Holds`; the server's r
|
||||
upload), and a deep analysis that loses it records nothing. A render whose folder another index moves while it runs is
|
||||
not stopped: its output can land in a folder created again at the old place, where its row keeps finding it.
|
||||
|
||||
A conversion (`MassConverter`) adds no writer of its own to a sequence's folder: it stages the files it makes in the
|
||||
archive's `staging/convert-<job>/`, then files them through the archive ingest (New sequence) or swaps them in through
|
||||
`FrameTrash.ReplaceAsync` (Replace), each under the sequence's lease, with the folder read from the index under it and
|
||||
its sidecar the sequence's (`SequenceFolders.Holds`, `SequenceWriter.ReadLocked`); the originals a Replace takes out go
|
||||
into the trash, never away. Its journals in `journal/` (`convert-<job>.json`, `.staged`, `.pins`) tell a resume, and
|
||||
another host's maintenance, what the job did.
|
||||
|
||||
Sync (desktop ↔ server, BRIEF §14.5) reuses the same paths: `SyncService` compares the local index with the server's
|
||||
listing (settings and tags carry version counters), uploads go through the chunked protocol into the server's
|
||||
`ArchiveIngest`, downloaded originals are verified and committed through the local `ArchiveIngest`, and proxies land
|
||||
@@ -174,7 +181,7 @@ run as server jobs whose progress comes from the events.
|
||||
|
||||
| To add | Implement / register |
|
||||
|---|---|
|
||||
| An image format or decoder | `IImageDecoderProvider` (managed in `Core/Imaging/Decoders` or `Codecs`, WIC in `Core.Windows`: a RAW only through the Raw Image Extension, checked per file); chained by `DecoderFactory` |
|
||||
| An image format or decoder | `IImageDecoderProvider` (managed in `Core/Imaging/Decoders` or `Codecs`, WIC in `Core.Windows`: a RAW only through the Raw Image Extension, checked per file; `DevelopsRawAt8Bits` when its RAWs come out at 8 bits); chained by `DecoderFactory`, and for a conversion by `FrameConverter.Decoders` |
|
||||
| A video encoder | `IVideoEncoderProvider` (`Core/Video/Managed`, `Core.Windows/MediaFoundation`); list it in the host's `ProcessingOptions.Encoders` |
|
||||
| A background operation | a `JobKind`, an `IJobHandler` (in `Data/Archiving/Jobs` or `Data/Processing/Jobs`) returned by the service's `CreateJobHandlers`; the job engine, Jobs screen, admin and API pick it up |
|
||||
| A server feature | a static `XxxEndpoints.Map(api)` in `Server/Api` with `.Requires(Permissions…)`, called from `ServerHost.ConfigurePipeline`; DTOs in `Chronos.Protocol` with the JSON context |
|
||||
|
||||
+309
-41
@@ -310,10 +310,12 @@ Primary entities (identical concepts in SQLite and PostgreSQL; ids are UUIDv7 st
|
||||
entries of a confirmed plan, erases nothing when the trash changed since, and is never
|
||||
scheduled: amended 2026-10-26, R6; move, stored as 14, a Reorganize that applies exactly a
|
||||
confirmed plan of new folders, titles and file names to sequences of the archive, its target,
|
||||
and holds the rest of it when paused, cancelled or failed: amended 2026-10-26, R7), target
|
||||
ids, state (queued, running, paused, done, failed, cancelled), progress (done/total, fps,
|
||||
eta), log tail, created by, node id, attempts, error, schedule id (the schedule that queued
|
||||
it; amended 2026-10-26, R10).
|
||||
and holds the rest of it when paused, cancelled or failed: amended 2026-10-26, R7; convert,
|
||||
stored as 19, a conversion of exactly the photos a confirmed plan lists, its targets the
|
||||
sequences, each converted all or nothing into its own frames or a new sequence: amended
|
||||
2026-10-26, R7), target ids, state (queued, running, paused, done, failed, cancelled),
|
||||
progress (done/total, fps, eta), log tail, created by, node id, attempts, error, schedule id
|
||||
(the schedule that queued it; amended 2026-10-26, R10).
|
||||
- **Schedule** (amended 2026-10-26, R10) — id, system key (set, and unique, on a host's
|
||||
system schedules, §14.6), name, action (scan, verify, thumbnails, proxies, analysis,
|
||||
maintenance, backup, cleanup, duplicates, orphans), target (`current`: the host's
|
||||
@@ -424,8 +426,9 @@ The archive is the source of truth; the database is an index that can be rebuilt
|
||||
│ ├── archive.json { id, name, schemaVersion, created, layoutTemplates, proxyPolicy }
|
||||
│ ├── index-snapshot.bin optional accelerator for rebuild (all sidecars concatenated + hash); ignored if stale
|
||||
│ ├── locks/ lease files for concurrent writers (server + client on same share)
|
||||
│ ├── journal/ rename-<plan>.json: a mass rename or Reorganize being applied (below; amended 2026-10-26, R7)
|
||||
│ └── trash/ deleted sequences and photos, kept until Empty (below; amended 2026-10-26, R6)
|
||||
│ ├── journal/ rename-<plan>.json: a mass rename or Reorganize being applied; convert-<job>.json, .staged, .pins: a conversion (below; amended 2026-10-26, R7)
|
||||
│ ├── staging/ copies an import is filing; convert-<job>/<sequence>/: the files a conversion made, until they take their place (below; amended 2026-10-26, R7)
|
||||
│ └── trash/ deleted sequences and photos, and originals a conversion replaced, kept until Empty (below; amended 2026-10-26, R6, R7)
|
||||
├── 2026/
|
||||
│ └── 2026-09-28 Canon EOS R5 - Harbour sunset/ folder = expanded FolderTemplate
|
||||
│ ├── originals/ IMG_0001.CR2 … names = expanded FileTemplate
|
||||
@@ -437,7 +440,7 @@ The archive is the source of truth; the database is an index that can be rebuilt
|
||||
│ ├── project.json render settings (the "project")
|
||||
│ ├── thumbs.pack packed thumbnails (one file per sequence, indexed; avoids 100k tiny files on SMB)
|
||||
│ ├── rename-files.json the file renames of a Reorganize a crash interrupted (below; amended 2026-10-26, R7)
|
||||
│ └── *.pending.json journals of an ingest, a photo deletion or a restore a crash interrupted (below)
|
||||
│ └── *.pending.json journals of an ingest, a photo deletion, a frame replacement (replace.pending.json, a conversion or its undo; amended 2026-10-26, R7) or a restore a crash interrupted (below)
|
||||
```
|
||||
|
||||
`sequence.json` (canonical, versioned, written atomically):
|
||||
@@ -447,8 +450,9 @@ tags, rating, notes, status, versions, createdBy, updatedAt, removed? }`. Amende
|
||||
R6: `removed: [{ sha256, replacement?, reason: Deleted | Replaced, at }]` holds the tombstones
|
||||
of the photos removed from the sequence (§5 FrameRemoval), left out when there are none;
|
||||
`frames[].source: { sha256, format, file, size }` names the file a converted frame was made
|
||||
from, reserved for R7 (read and written, nothing acts on it yet). A build that does not know
|
||||
either field keeps it and writes it back unchanged.
|
||||
from: a conversion's Replace writes it, and its undo and a conversion job that resumes read it
|
||||
(amended 2026-10-26, R7). A build that does not know either field keeps it and writes it back
|
||||
unchanged.
|
||||
|
||||
Trash (amended 2026-10-26, R6). Nothing in it is erased except by *Empty* (§12.5, §14.8):
|
||||
- `trash/<id>[-<time>[-n]]/` with `<name>.json` beside it: a deleted sequence folder, whole
|
||||
@@ -458,8 +462,10 @@ Trash (amended 2026-10-26, R6). Nothing in it is erased except by *Empty* (§12.
|
||||
from sequence `<id>`, each original with its XMP companion when no photo that stays shares
|
||||
it, and the record: each photo's frame record, each file's former place, size and SHA-256,
|
||||
the sequence's title and folder, who deleted them, when, and the kind (photos, or replaced
|
||||
for originals a conversion replaced, R7). A photo never hashed is hashed as it goes; one
|
||||
whose original was already missing goes with its record alone.
|
||||
for originals a conversion replaced, R7: such an entry also keeps each photo's replacement
|
||||
SHA-256, a copy of the sequence's `analysis.json` and the job that made it). A photo never
|
||||
hashed is hashed as it goes; one whose original was already missing goes with its record
|
||||
alone.
|
||||
- `trash/.erasing/`: entries moved aside by Empty before they are deleted, so a listing never
|
||||
sees half an entry; leftovers are deleted by the next Empty.
|
||||
- In a sequence's `.chronos/`, `remove.pending.json` is written before a photo deletion's
|
||||
@@ -471,6 +477,19 @@ Trash (amended 2026-10-26, R6). Nothing in it is erased except by *Empty* (§12.
|
||||
the entry, or the record without the photos the sidecar lists again). A restore into a new
|
||||
sequence stages each original in `<entry>/.restoring/` (never the archive's staging) and
|
||||
puts it back on any failure.
|
||||
- A replaced entry (amended 2026-10-26, R7) goes back by a swap: while every converted frame
|
||||
still holds its conversion (re-hashed) and names the original as its `source`, the originals
|
||||
take their frames' place again as a Replace does (below), the converted files going into a
|
||||
replaced entry in turn and the entry's `analysis.json` back into the sequence; otherwise the
|
||||
originals come back as a new sequence. *Empty* erases it only while each conversion of its
|
||||
originals still hashes to its SHA-256 where the archive shows it now; of a conversion deleted
|
||||
since, every copy the trash still holds must hash to it, and with none left nothing keeps the
|
||||
entry. The archive is asked, never this host's index alone: the sequence's sidecar where the
|
||||
index or the entry says it is, in the trash, or found by walking the archive's folders,
|
||||
followed through its replaced tombstones. A conversion counts as deleted only when the
|
||||
sidecar shows it (a deleted tombstone, or its frame gone while every frame is hashed and no
|
||||
photo of the folder is unlisted), when the sequence is in the trash, or when no sidecar of it
|
||||
exists and the index has no row of it; whatever the archive cannot tell keeps the entry.
|
||||
|
||||
Deleting photos writes the sidecar without them (frames version + 1) and with a tombstone of
|
||||
each SHA-256 no photo that stays holds, and clears what covered the frames (light and deep
|
||||
@@ -516,7 +535,48 @@ step being one sequence and the sequences nested in a folder that moves with it:
|
||||
- Proxies (named by frame index), thumbnails (by index and content hash), tombstones and trash
|
||||
records need nothing; a photo restored from the trash comes back under the name it had.
|
||||
|
||||
Rules: originals are immutable (never rewritten; edits are settings); every write of a
|
||||
Conversion (amended 2026-10-26, R7; §8.7, §12.5, §14.8) writes over no original: Replace
|
||||
moves each original into the trash, New sequence leaves it where it is.
|
||||
- A `convert` job takes one sequence at a time. Under the sequence's lease, its sidecar settled
|
||||
where the index has it then, it plans the sequence again and goes on only while the photos the
|
||||
confirmed plan listed are there with the content confirmed; it pins them in
|
||||
`journal/convert-<job>.pins` and from then on, a retry included, converts those alone, so
|
||||
photos received or verified since stay as they are. A sequence another index moved away (its
|
||||
folder gone, or holding another sequence) is left for the retry after this index's scan.
|
||||
- Stage A, without the lease: each original is re-hashed against its record, converted and
|
||||
verified (§8.7) into `staging/convert-<job>/<sequence>/`, several at once, and each staged file
|
||||
is appended to `journal/convert-<job>.staged`; `journal/convert-<job>.json` records what each
|
||||
sequence came to and whether the passes it needs were queued. A resumed or retried job keeps
|
||||
the staged files whose SHA-256 still verifies, settles a replacement a crash left half-way,
|
||||
and takes a sequence it had replaced already as converted.
|
||||
- Stage B, under the lease and while every photo pinned still holds its content, all or
|
||||
nothing: Replace swaps the files of the frames (next point); New sequence files the converted
|
||||
copies into a new sequence through the archive ingest (§12.5).
|
||||
- A Replace, and the undo of one, writes `replace.pending.json` in the sequence's `.chronos/`
|
||||
first. Each swapped frame's original and its XMP companions go into one trash entry of kind
|
||||
replaced; each converted file comes in under the name filing gives a photo of the sequence
|
||||
(§7.1, with the target's extension), never onto a file there, those leaving included (`_2`…).
|
||||
The frames keep their ids and indices; each record takes the converted file's size, SHA-256,
|
||||
format, upright size and full-resolution tier, orientation 1, no preview, the flags of that
|
||||
file and those the user set, and a `source` naming the original. The sidecar (its frames
|
||||
version one higher, analyses, thumbnails and proxies cleared) gains a replaced tombstone per
|
||||
original naming its replacement, and content that comes back loses its tombstone; then the
|
||||
index follows, the proxies of the swapped frames are deleted and the passes the frames need
|
||||
are queued. The journal records its phase (moving, written, undoing) and each frame's new
|
||||
name: the next writer of the sequence completes a replacement whose sidecar lists a new name
|
||||
and undoes any other, and an undo that fails stops that writer, as a deletion's recovery
|
||||
does. Every writer that changes the frames (an ingest, a deletion, a restore, a Reorganize
|
||||
step, a sequence deletion) settles it first, or waits while it cannot be settled yet (the
|
||||
trash entry an undo takes its files from is busy); a scan settles it too, and reconciles
|
||||
nothing in the folder while it stays.
|
||||
- The job's journals and staging go once every sequence is final. Maintenance keeps a job's
|
||||
staging while the job is queued, running or paused, removes it at once when the job is done
|
||||
and otherwise once its files are a day idle, and removes the journal when the job is done. A
|
||||
job this index does not know (another host's on a shared archive) keeps both while any of
|
||||
their files was written within 90 days, then both go.
|
||||
|
||||
Rules: originals are immutable (never rewritten; edits are settings; a conversion takes an
|
||||
original out of its sequence only into the trash, amended 2026-10-26, R7); every write of a
|
||||
sidecar goes to a temp file, `fsync`, rename; the folder name is derived from templates at
|
||||
import time and never auto-renamed afterwards: only Reorganize, an explicit user action
|
||||
behind a dry run, moves and renames what is filed, updating sidecars and DB together
|
||||
@@ -569,7 +629,7 @@ One naming rule for import, upload and Reorganize (amended 2026-10-26, R7):
|
||||
|---|---|---|---|---|
|
||||
| JPEG | jpg jpeg jpe jfif | APP1 Exif/XMP, MPF | WIC or managed | managed (baseline + progressive) |
|
||||
| PNG | png | eXIf, iTXt XMP | WIC or managed | managed |
|
||||
| TIFF | tif tiff | IFDs | WIC or managed | managed (strips/tiles; none/PackBits/LZW/Deflate/JPEG) |
|
||||
| TIFF | tif tiff | IFDs | WIC or managed | managed (strips/tiles; none/PackBits/LZW/Deflate/JPEG; gray, RGB and linear RAW samples only: a CMYK, CIELab or palette TIFF is unavailable, never read as gray; amended 2026-10-26, R7) |
|
||||
| DNG (smartphones: Apple ProRAW, Android, Samsung; DJI; Insta360; Leica; Pentax; Ricoh; GoPro files converted by Adobe software) | dng | IFDs, MakerNote | managed full decode (amended 2026-10-16, R4) | managed full decode |
|
||||
| Canon | cr2 cr3 | cr2: TIFF; cr3: ISO-BMFF `CMT1..4` | WIC (Raw ext.) → managed CR2 (P1) → embedded preview | managed CR2 (P1) → embedded full-size JPEG (CR3 track 1) |
|
||||
| Nikon | nef nrw | TIFF | WIC → managed NEF (P1) → preview | managed NEF (P1) → preview |
|
||||
@@ -617,11 +677,17 @@ dims, delta), `WhiteLevel`, `AsShotNeutral`/`AsShotWhiteXY`, `ColorMatrix1/2` +
|
||||
|
||||
- `JpegDecoder` (baseline, progressive, restart intervals, 4:4:4/4:2:2/4:2:0/4:1:1/gray,
|
||||
12-bit optional, ICC ignored), `JpegEncoder` (baseline, quality 1–100, subsampling
|
||||
choice, optimised Huffman tables optional, Exif/XMP APP1 embedding).
|
||||
choice, optimised Huffman tables optional, Exif/XMP APP1 embedding, an ICC profile in APP2
|
||||
chunks: amended 2026-10-26, R7).
|
||||
- `PngDecoder`/`PngEncoder` (all colour types, 8/16-bit, Adam7 decode, filters, zlib via
|
||||
`System.IO.Compression.ZLibStream`).
|
||||
- `TiffReader`/`TiffWriter` (as prototype: 16-bit TIFF, linear DNG writer with
|
||||
`PhotometricInterpretation=34892`).
|
||||
- `TiffReader`/`TiffWriter` (as prototype: 16-bit TIFF, an ICC profile in tag 34675, linear DNG
|
||||
writer with `PhotometricInterpretation=34892`, scene-referred for a conversion, §8.7: amended
|
||||
2026-10-26, R7).
|
||||
- `IccProfile` (amended 2026-10-26, R7): ICC profiles read and written (matrix/TRC and gray,
|
||||
`curv`/`para` curves, `desc`/`mluc` text), an in-house Adobe RGB (1998)-compatible and a
|
||||
Display P3 profile, and what a photo's headers say of its colour space (JPEG APP2, PNG
|
||||
iCCP/sRGB, TIFF tag 34675, HEIF/AVIF `colr`, WebP ICCP, Exif ColorSpace and Interop).
|
||||
- `GifEncoder` (animated; median-cut palette + Floyd–Steinberg; frame differencing).
|
||||
- `ApngEncoder`.
|
||||
- `AviMjpegWriter` (RIFF AVI with `MJPG`, OpenDML index for > 2 GB).
|
||||
@@ -650,6 +716,44 @@ size and budget, never by sequence length; the self-tests assert this.
|
||||
`SHFormatDrive` (format card), `ShellExecute("open", url)` (links, Store pages),
|
||||
`ShellExecute("explore", folder)` (reveal in Explorer). Nothing else.
|
||||
|
||||
### 8.7 Conversion (amended 2026-10-26, R7; §7, §12.5)
|
||||
|
||||
A conversion makes each photo a JPEG (baseline, 4:4:4, optimised Huffman tables, 8-bit,
|
||||
quality 1–100, default 95), a 16-bit TIFF (RGB, Deflate with the predictor) or a linear DNG
|
||||
(16-bit LinearRaw, lossless JPEG tiles), the archival choice.
|
||||
- Decoding: at full resolution only, never from an embedded preview, upright. The managed
|
||||
decoders come first for every format they read natively (a RAW developed in-house at float
|
||||
precision, the same on every host), WIC only for what they do not read. A 16-bit target never
|
||||
takes a RAW through a decoder that develops it at 8 bits (WIC's Raw Image Extension): such a
|
||||
RAW converts to JPEG only. The server decodes with the managed decoders alone, so it converts
|
||||
no CR3, HEIC or RAW body its developer does not support, nor a CMYK, CIELab or palette TIFF,
|
||||
an unsupported compression or a file past their size limits: its dry run says to convert
|
||||
those photos on a PC, which reads them through WIC.
|
||||
- A linear DNG keeps what a RAW develops: the values are stored in linear ProPhoto primaries
|
||||
(colours outside sRGB stay positive), divided by the power of two, at most 2^4, that brings
|
||||
their peak under white, which BaselineExposure gives back; ColorMatrix1 and ForwardMatrix1
|
||||
describe that space (illuminant D65, AsShotNeutral 1/1/1). The as-shot white balance is baked
|
||||
in and values below black are clipped. An export's DNG stays clipped linear sRGB (§11.3).
|
||||
- Colour: the colour space the original's values are in is kept. A JPEG or TIFF carries the
|
||||
original's ICC profile with its code values unchanged (a float TIFF's linear values are coded
|
||||
with the profile's own curves); a DNG gets the values converted through a matrix/TRC profile
|
||||
(an sRGB one, told by its numbers, needs nothing); a gray profile converts to sRGB. Exif Adobe
|
||||
RGB (uncalibrated with Interop R03) and a HEIF nclx box with P3 primaries get the in-house
|
||||
profiles. A space none of that keeps (CMYK, Lab, a lookup-table profile into a DNG, Exif
|
||||
uncalibrated without R03, other nclx primaries or an HDR transfer, a profile that does not
|
||||
parse) is not converted. A photo that records none is sRGB.
|
||||
- Metadata: capture time (to the tick), offset, exposure, f-number, ISO, focal length, bias and
|
||||
white balance from the sidecar; camera, serial, lens, 35 mm focal length, exposure program,
|
||||
metering mode, flash, GPS, artist and copyright from the original, the sequence's camera and
|
||||
lens where it names none. MakerNote and XMP are not carried; the orientation is 1.
|
||||
- Size: a photo is not converted when the target cannot hold it (a JPEG side above 65535) or
|
||||
the server's decoders could not read it back (a JPEG above 2^28 pixels; a TIFF-16 or DNG
|
||||
above 2^29 samples, about 179 MP).
|
||||
- Each converted file is hashed as it is made and written atomically, then read back (the same
|
||||
size and SHA-256), its metadata read again (format, capture time and offset) and decoded by
|
||||
the server's decoders at full resolution and size; a file that fails any of these is deleted
|
||||
and its photo fails.
|
||||
|
||||
---
|
||||
|
||||
## 9. Metadata model and parsers (`Chronos.Core/Metadata`)
|
||||
@@ -669,7 +773,9 @@ WhiteBalance mode + Kelvin if present, Flash, Orientation, dimensions, Make/Mode
|
||||
Lens, GPS (lat/lon/alt), Artist/Copyright, Rating/Label from XMP, `Software`. All parsers
|
||||
are fuzz-safe (no exception escapes; malformed input yields partial metadata + a warning).
|
||||
|
||||
`ExifWriter` (prototype) is kept for proxies/exports: writes a minimal, valid Exif block.
|
||||
`ExifWriter` (prototype) is kept for proxies, exports and converted photos: writes a minimal,
|
||||
valid Exif block, with the exposure program, metering mode, flash and white balance when known
|
||||
(amended 2026-10-26, R7).
|
||||
|
||||
---
|
||||
|
||||
@@ -864,9 +970,10 @@ player smoke test on Windows CI.
|
||||
status chips: `✓` analysed, `▣` proxies, `▶n` renders, `☁` synced/origin, `!` warnings.
|
||||
Hover reveals quick actions: Open, Analyse, Render preset, Sync.
|
||||
- Multi-select → mass actions bar (Analyse, Build proxies, Verify, Tag, Rate,
|
||||
Reorganize…, Upload, Download, Delete, Export list as CSV). Reorganize… (amended
|
||||
2026-10-26, R7; formerly Move) takes the selected sequences of one archive, never a
|
||||
server-only one, into the dialog of §12.5.
|
||||
Reorganize…, Convert…, Upload, Download, Delete, Export list as CSV). Reorganize… (amended
|
||||
2026-10-26, R7; formerly Move) and Convert… (amended 2026-10-26, R7) take the selected
|
||||
sequences of one archive, never a server-only one, into their dialogs of §12.5; a selection
|
||||
of two archives is refused with the reason.
|
||||
- Filters are chips; saved views (e.g. "Night, 4K, not rendered"); search is instant
|
||||
(indexed columns); everything virtualized (in-house `VirtualizingWrapPanel`).
|
||||
- Photos deleted from a sequence (amended 2026-10-26, R6; on the admin panel, §14.8, or by
|
||||
@@ -938,7 +1045,7 @@ player smoke test on Windows CI.
|
||||
│ ● SD 128 GB EOS R5 card A ▲ │ Destination (•) Archive ( ) Folder [D:\Shoots …] ( ) Server ☁ "Studio NAS" │
|
||||
│ ● microSD 64 GB GoPro 12 │ Scan [✓] Subfolders Sessions [✓] gap [45] min · min [8] frames [✓] Verify hashes │
|
||||
│ ○ E:\ no DCIM │ Names {year}/{date} {camera} / {date}_{time}_{n:0000} → 2026/2026-09-28 Canon EOS R5/2026-09-28_18-02-11_0001.CR2 │
|
||||
│ ○ Folder… │ On existing (•) Skip ( ) Rename ( ) Overwrite Convert (•) Copy ( ) TIFF-16 ( ) Linear DNG ( ) JPEG │
|
||||
│ ○ Folder… │ On existing (•) Skip ( ) Rename ( ) Overwrite │
|
||||
│ │ After import (•) Keep card ( ) Delete imported ( ) Format card [✓] Eject [✓] Deep analysis │
|
||||
│ [✓] Import automatically when │ Plan 3 sessions · 4,812 photos · 96.2 GB · 12 min [Show plan] [ Import ▶ ] │
|
||||
│ a known card is inserted │ │
|
||||
@@ -963,6 +1070,11 @@ player smoke test on Windows CI.
|
||||
panel have no Group choice.
|
||||
- Copy with hash while streaming; verify by re-reading destination; only then delete or
|
||||
format (OS dialog); eject via `IOCTL_STORAGE_EJECT_MEDIA` after `FSCTL_LOCK_VOLUME`.
|
||||
- Import copies every photo byte for byte and converts nothing (amended 2026-10-26, R7; the
|
||||
sketch's former *Convert* row is gone): deleting imported photos and formatting the card
|
||||
need archived copies that re-hash to the card's files, which a converted file never does,
|
||||
and originals are immutable. Converting is a separate, explicit step after import, behind a
|
||||
dry run (*Convert…*, §12.5, §14.8); a photo converted since keeps its card copy (§13).
|
||||
- Destination "Server" streams frames through the client to the server (§14.4); the
|
||||
server confirms each hash before the client counts it as imported.
|
||||
- Auto-import on insertion (per card), with the OS toast "Card X detected — Import".
|
||||
@@ -977,7 +1089,7 @@ player smoke test on Windows CI.
|
||||
│ Index health: ✓ sidecars 412/412 · ⚠ 3 sequences without proxies · ⚠ 1 unverified since 90 days │
|
||||
│ Recent maintenance: 2026-09-20 verify ✓ · 2026-09-01 vacuum ✓ │
|
||||
├──────────────────────────────────────────────────────────────────────────────────────────────────────┤
|
||||
│ Mass operations on filtered set (412): [Analyse] [Proxies] [Thumbnails] [Verify] [Reorganize…] [Retag] [Export CSV] [Delete] │
|
||||
│ Mass operations on filtered set (412): [Analyse] [Proxies] [Thumbnails] [Verify] [Reorganize…] [Convert…] [Retag] [Export CSV] [Delete] │
|
||||
```
|
||||
|
||||
Operations: **Scan** (incremental, mtime/size), **Rebuild index** (from sidecars; falls
|
||||
@@ -1008,6 +1120,15 @@ those entries and nothing when the trash changed since; an entry that changes wh
|
||||
is kept, and the job then fails after erasing the others. It is the only way the product
|
||||
erases trash entries; no schedule runs it (§14.6).
|
||||
|
||||
Originals a conversion replaced (amended 2026-10-26, R7; §7) are listed as *Replaced
|
||||
originals*. *Restore* swaps them back into their sequence while its converted frames are
|
||||
unchanged, the conversions going to the trash in turn, and otherwise brings them back as a
|
||||
new sequence. *Empty…*'s list names first, wherever the trash lists them, the entries whose
|
||||
conversion was deleted since (*conversion deleted*: they may hold the last copy of their
|
||||
photos), the others filling its six lines and the rest counted. The job keeps, each logged
|
||||
with why, an entry changed since the plan, one whose sequence is busy, one whose conversion
|
||||
no longer matches, and one whose conversion the archive cannot locate (a scan settles it).
|
||||
|
||||
*Reorganize…* (amended 2026-10-26, R7; it replaces Rename… and Move…) applies new templates
|
||||
to sequences already filed: the set (online), the Library's selection (§12.2), or every
|
||||
sequence of the archive from the toast of Settings › Archive (§12.8). The admin panel offers
|
||||
@@ -1052,6 +1173,55 @@ the same (§14.8), through the same engine and job.
|
||||
Archive and Library screens read the archive again when it ends; an editor open on a
|
||||
sequence it changed reloads where the sequence is now after that sequence's step.
|
||||
|
||||
*Convert…* (amended 2026-10-26, R7; §7, §8.7) converts the photos of sequences already filed
|
||||
to JPEG, 16-bit TIFF or linear DNG: the set (online), or the Library's selection (§12.2). The
|
||||
admin panel offers the same (§14.8), through the same engine and job.
|
||||
- An in-window dialog: Format (JPEG, TIFF 16-bit, Linear DNG; Linear DNG, the archival choice,
|
||||
chosen first), Quality (JPEG only, 1–100, 95) and Mode, *Replace* (the converted files take
|
||||
the photos' place in their sequences; the originals go to the archive's trash, restorable
|
||||
until it is emptied) or *New sequence* (converted copies in a new sequence beside each source;
|
||||
the originals stay as they are). The mode is chosen at every run: it starts unchosen at every
|
||||
open and is never remembered. Each choice's tooltip says what becomes of the originals.
|
||||
- The dry run (nothing touched) follows the choices (400 ms after typing the quality; Enter at
|
||||
once) and lists each sequence that converts, skips photos or stays whole: its photos and size
|
||||
before → after (an estimate), the photos that stay as they are and why (already in that
|
||||
format; a format this computer cannot read at full resolution; read only from an embedded
|
||||
preview; a RAW developed here at 8 bits only, for a 16-bit format; a colour profile the format
|
||||
can neither keep nor convert; larger than the format holds; unreadable; missing; never
|
||||
verified; held open by another program or not openable), or why the whole sequence stays (a
|
||||
job works on it, or a conversion of it waits; the archive offline or read-only; its sequence
|
||||
file unreadable). With New sequence, the photos a copied sequence skips are *not copied* into
|
||||
its new one. A summary ("12 of 36 change · 3,600 photos · 41 GB → 32 GB · 20 skipped") and the
|
||||
space line follow ("Needs 12 GB, free 340 GB": the estimate with a 15 % margin and a 512 MiB
|
||||
reserve, against the free space where the conversion writes); a volume without the space
|
||||
blocks Apply. The mode does not change what converts, so choosing it plans nothing again.
|
||||
- *Apply* (enabled for the dry run of the choices on screen when it converts something and the
|
||||
space is there, once a mode is chosen, which is asked last) asks a Replace to type the number
|
||||
of photos it replaces, and confirms a New sequence with how many photos the new sequences
|
||||
lack; it then queues the *Convert* job of exactly that plan at user priority, and the dialog
|
||||
closes. A conversion of one of its sequences already queued or running refuses it: the dry
|
||||
run is made again and shows those sequences busy. Cancel is the default button.
|
||||
- The job (desktop and server) converts one sequence at a time, all or nothing: the photos the
|
||||
dry run listed alone, each only while it holds the content confirmed; photos received since
|
||||
stay as they are. It checks the free space before it starts, before each sequence and before
|
||||
each photo, and stops before the volume fills. Paused, resumed or retried in Jobs, it keeps
|
||||
what it converted. A sequence whose confirmed photos changed is left as it is, and a retry
|
||||
leaves it too (plan again); one busy, moved away by another program or with a photo held open
|
||||
waits for the retry; one with a photo that cannot be converted is left as it was, what it
|
||||
converted kept for the retry. The job's log says each, and the job fails at the end saying
|
||||
how many.
|
||||
- New sequence: titled "title (JPEG|TIFF|DNG)", in a folder from the archive's template, its
|
||||
photos named as filing names them, owned as its source is, with its source's tags, rating,
|
||||
notes and project (the positions on photos it lacks wait as pending frames). It holds the
|
||||
converted copies alone; the job log says how many photos stayed in the source alone.
|
||||
- When a Replace job ends, its toast offers *Undo* (once, never from the Windows notification):
|
||||
the replaced entries that job made go back (swapped back, or as a new sequence for one that
|
||||
changed since). Later, *Trash…* › *Restore* does the same, and the admin panel's trash view
|
||||
for a conversion the server ran.
|
||||
- A running or paused conversion makes its sequences busy. The Library and Archive screens read
|
||||
the sequences again when it ends (a failed one converted the others); an editor open on a
|
||||
converted sequence reloads.
|
||||
|
||||
### 12.6 Jobs
|
||||
|
||||
Two tabs, a *Queue | Scheduled* segmented control first in the toolbar (amended 2026-10-26,
|
||||
@@ -1170,6 +1340,9 @@ update check on start (§18) runs whatever screen is open.
|
||||
its sequence carries, as Reorganize names it (amended 2026-10-26, R7).
|
||||
- Post-actions: keep / delete imported files (only those verified) / format card (OS
|
||||
dialog) / eject; run deep analysis automatically (default on, background, low priority).
|
||||
A photo whose archived frame a conversion replaced since no longer matches its card file,
|
||||
so a delete keeps it on the card and a format is refused while it is there (amended
|
||||
2026-10-26, R7).
|
||||
- Failure handling: card removed mid-copy → partial files deleted, plan resumable on
|
||||
re-insert; errors listed per file, never a modal per error.
|
||||
|
||||
@@ -1255,6 +1428,7 @@ POST /api/v1/nodes/register · POST /nodes/{id}/heartbeat · POST /nodes/{id}/
|
||||
|
||||
GET/PUT /api/v1/archive/settings · POST /archive/scan · /rebuild · /verify · GET /archive/stats · POST /archive/maintenance (admin)
|
||||
POST /api/v1/archive/reorganize {sequenceIds|all, folderTemplate?, fileTemplate?, titleTemplate?, dryRun, fingerprint?} → plan | 202 move job (admin)
|
||||
POST /api/v1/archive/convert {sequenceIds|all, target, quality?, mode, dryRun, fingerprint?} → plan | 202 convert job (admin)
|
||||
GET /api/v1/archive/trash · POST /archive/trash/{name}/restore · POST /archive/trash/empty {names?, dryRun, fingerprint} (admin)
|
||||
GET /api/v1/i18n/{culture} strings for the web admin
|
||||
```
|
||||
@@ -1297,14 +1471,18 @@ Library and trash (amended 2026-10-26, R6):
|
||||
another's), `folder_in_use`; 422 `trash_mismatch` (no file matches its record any more, or a
|
||||
deleted sequence's own sidecar no longer names it); 503 `archive_offline`. Audited
|
||||
`trash_restored`; publishes `sequenceChanged` `created` (a sequence, or a new one) or
|
||||
`frames`.
|
||||
`frames`. A replaced entry (amended 2026-10-26, R7) answers kind `replaced`, with
|
||||
`newSequence` false once its originals swapped back in place of their conversions, true when
|
||||
they came back as a new sequence.
|
||||
- Empty: a dry run answers the entries measured on disk, their photos, files and bytes, the
|
||||
plan's `fingerprint` and the names asked for that the trash does not hold (`unknown`); the
|
||||
erase sends the fingerprint back and answers 202 with the `empty-trash` job. Errors: 400
|
||||
`bad_request` (`names`, `fingerprint`); 409 `trash_changed` (details: the fingerprint now),
|
||||
`job_unavailable`; 503 `archive_offline` (offline, and for the erase also read-only; the
|
||||
listing answers it too, offline). The request is audited `trash_empty_requested`; what the
|
||||
job erased is in its log.
|
||||
plan's `fingerprint` and the names asked for that the trash does not hold (`unknown`); a
|
||||
replaced entry whose conversion the archive shows deleted carries `conversionDeleted: true`,
|
||||
which the fingerprint covers (amended 2026-10-26, R7). The erase sends the fingerprint back
|
||||
and answers 202 with the `empty-trash` job. Errors: 400 `bad_request` (`names`,
|
||||
`fingerprint`); 409 `trash_changed` (details: the fingerprint now), `job_unavailable`; 503
|
||||
`archive_offline` (offline, and for the erase also read-only; the listing answers it too,
|
||||
offline). The request is audited `trash_empty_requested`; what the job erased, and why it
|
||||
kept an entry, is in its log.
|
||||
- The manifest gains `removed: [{sha256, replacement, reason: deleted|replaced, at}]` (null
|
||||
when there are none; covered by its ETag, since a deletion moves the frames version).
|
||||
|
||||
@@ -1337,10 +1515,11 @@ Reorganize (amended 2026-10-26, R7; ManageArchive; §7, §12.5, §14.8):
|
||||
photo count, frames version and how many of their photos are hashed; the title of the others
|
||||
inside their folders. The same dry run again, and its confirmation, take the kept plan. A
|
||||
plan is made apart from its request (one a proxy cuts off leaves it to be made, and asking
|
||||
again waits for it), at most 2 at once and 8 kept or being made; one still being made 15
|
||||
minutes after it was asked, let go for newer ones, or when the server stops is stopped, and
|
||||
its requests answer 503 `plan_dropped`. A change made on disk alone is not in the stamp: the
|
||||
confirmation then answers 202, and the job, which plans again, fails without changing anything.
|
||||
again waits for it), at most 2 at once and 8 kept or being made (Convert's dry runs counted,
|
||||
R7); one still being made 15 minutes after it was asked, let go for newer ones, or when the
|
||||
server stops is stopped, and its requests answer 503 `plan_dropped`. A change made on disk
|
||||
alone is not in the stamp: the confirmation then answers 202, and the job, which plans again,
|
||||
fails without changing anything.
|
||||
- `invalid_template`, here and from `PUT /archive/settings`: the details name the field and,
|
||||
after a colon, the rule a template that parses breaks (`folderTemplate:reserved_folder`,
|
||||
`fileTemplate:file_separator`, `fileTemplate:extension`, `fileTemplate:not_unique`), the
|
||||
@@ -1358,12 +1537,52 @@ Reorganize (amended 2026-10-26, R7; ManageArchive; §7, §12.5, §14.8):
|
||||
answers 503 `sequence_busy` while the sequence is held, 404 `frame` when the sequence or its
|
||||
folder is gone, or the folder is another sequence's.
|
||||
|
||||
Convert (amended 2026-10-26, R7; ManageArchive; §7, §8.7, §12.5, §14.8):
|
||||
- The request names exactly one of `sequenceIds` (1–1,000) and `all`, a `target` (`jpeg`,
|
||||
`tiff16`, `linear-dng`), a `quality` (1–100, default 95; it counts for a JPEG only) and a
|
||||
`mode` (`replace` or `new-sequence`). A dry run answers `{target, quality, mode, steps,
|
||||
sequences, photos, skipped, bytesBefore, bytesAfter, space, fingerprint}` and changes nothing:
|
||||
a step per sequence asked, in order, `{sequenceId, title, folder, framesVersion, photos,
|
||||
bytesBefore, bytesAfter (an estimate), skipped: [{reason: same_format|convert_on_pc|
|
||||
undecodable|missing|unhashed|eight_bit|color_profile|too_large|inaccessible, photos,
|
||||
message}], blocked: [{reason: busy|offline|unreadable, message}]}`, each message in the
|
||||
request's language. `convert_on_pc` is a format or file the server cannot read at full
|
||||
resolution ("convert these photos on a PC"); of a sequence `new-sequence` copies, a message
|
||||
says the new sequence lacks those photos. `space` is `{required, free, enough, message}`:
|
||||
the estimate × 1.15 plus 512 MiB, counted in both modes, against the free space where the
|
||||
conversion writes (the tighter of the space path's volume and the archive's own, §14.9).
|
||||
- The change sends the dry run's fingerprint back and answers 202 with the `convert` job, whose
|
||||
parameters name each sequence's photos and their digest. Errors: 400 `bad_request`
|
||||
(`sequenceIds`, `target`, `quality`, `mode`, `fingerprint`); 404 `not_found` (`sequence`);
|
||||
409 `plan_changed` (details: the fingerprint now; none when a conversion of these sequences
|
||||
was queued meanwhile), `nothing_to_convert`, `not_enough_space` (details: the bytes needed),
|
||||
`job_unavailable`; 503 `archive_offline`, `plan_dropped`. Audited `archive_converted`
|
||||
(sequences · photos · target · mode). The job publishes `sequenceChanged` `converted` for each
|
||||
sequence whose frames it replaced and `created` for each new sequence, as each one completes.
|
||||
- The fingerprint is a SHA-256 of the options, the mode, and each sequence with its frames
|
||||
version, its photos' count and bytes, their digest (each frame id with the SHA-256 of its
|
||||
content), what it skips and what blocks it.
|
||||
- The server keeps a dry run as it keeps Reorganize's, in one cache for both (2 made at once,
|
||||
8 kept, 5 minutes, stopped after 15 with `plan_dropped`), keyed by the archive, the selection,
|
||||
the target with the quality that counts (none for a lossless target) and a stamp of the index:
|
||||
Reorganize's, and of the planned sequences' photos their count, sizes, formats, pixel sizes
|
||||
and how many are flagged missing, corrupt, preview-only or undecodable. Not the mode, which is
|
||||
set on the kept plan, nor the busy sequences and the free space, measured again at every
|
||||
request. A plan made while the archive was offline is not kept. A confirmation takes only the
|
||||
plan kept for the index as it is now and never plans inside its own request: with none kept
|
||||
it answers 503 `plan_dropped` (ask the dry run again), with a kept plan that differs 409
|
||||
`plan_changed`. A change made on disk alone is found by the job, which converts the photos
|
||||
confirmed only while each holds the content confirmed.
|
||||
|
||||
Uploads (amended 2026-10-26, R3, R6): `server/info` lists `extensions`, the photo file
|
||||
extensions the archive files (lower case, no dot), which the admin panel's dialog keeps to. A
|
||||
frame upload whose file name starts with `.` is 400 `invalid_file_name`. A start whose
|
||||
SHA-256 the target sequence tombstoned (and none of its frames holds) answers 200
|
||||
`alreadyExists` without a `frameId`, unless `restore` is true; the completion checks again
|
||||
unless `?restore=true` and answers 409 `photo_removed`, the upload cancelled (§14.4).
|
||||
unless `?restore=true` and answers 409 `photo_removed`, the upload cancelled (§14.4). An
|
||||
original a conversion replaced in the target sequence is tombstoned too; sent with `restore`,
|
||||
it files nothing and its completion answers the frame that holds its conversion (amended
|
||||
2026-10-26, R7).
|
||||
|
||||
Schedules (amended 2026-10-26, R10; ManageArchive, every change audited): `PUT` and
|
||||
`PATCH` change the fields given; an invalid field is 400 `invalid_schedule` with the field
|
||||
@@ -1411,6 +1630,14 @@ whose file name starts with `.` (the AppleDouble `._` files a Mac leaves on card
|
||||
files) is refused for every client (400 `invalid_file_name`), as the archive scanner leaves
|
||||
such files out.
|
||||
|
||||
Replaced photos (amended 2026-10-26, R7): a photo a conversion replaced in a sequence is in it
|
||||
as its conversion. The ingest answers its original (a card or a folder imported again, a
|
||||
download, an upload sent with `restore`) as a duplicate of the frame that holds the conversion,
|
||||
followed through later conversions, and keeps the tombstone that makes sync count both as one
|
||||
photo; once no such frame is intact, the original is filed again. A batch files nothing into a
|
||||
sequence while a restore from the trash or a frame replacement of it is not settled (its trash
|
||||
entry busy): an upload's completion answers 503 and the client tries again.
|
||||
|
||||
The admin panel uploads through the same path (amended 2026-10-26, R3; the dialog, §14.8):
|
||||
- It hashes each photo in the browser with an in-house incremental SHA-256 (FIPS 180-4,
|
||||
`sha256.js`) in a same-origin module worker (`hash-worker.js`, under the panel's
|
||||
@@ -1456,17 +1683,28 @@ Removed photos (amended 2026-10-26, R6). A photo deleted on one side leaves a to
|
||||
no upload of a photo the server deleted, no download of one this PC deleted; sync never
|
||||
deletes local files either way. A tombstone leaves a photo out only while its own side holds
|
||||
no matching photo (by hash, or by size and capture time while unhashed), so a duplicate that
|
||||
stays or a file put back by hand still syncs. A photo replaced by a converted file (R7)
|
||||
counts as its replacement on both sides, an alias followed up to 8 steps, for the
|
||||
comparison, the transfers and the frame positions. Content known only once hashed is checked
|
||||
then: a download skips an unhashed server frame this PC deleted (or holds as its
|
||||
replacement), and an upload skips an unhashed local frame the server deleted and then runs
|
||||
the archive verify, so the index gets the hashes and the next comparison leaves it out.
|
||||
stays or a file put back by hand still syncs. A photo replaced by a converted file (R7) is
|
||||
the same photo as its replacement on both sides, for the comparison, the transfers and the
|
||||
frame positions (below). Content known only once hashed is checked then: a download skips an
|
||||
unhashed server frame this PC deleted (or holds as its replacement), and an upload skips an
|
||||
unhashed local frame the server deleted and then runs the archive verify, so the index gets
|
||||
the hashes and the next comparison leaves it out.
|
||||
Known limitations: until the server verifies such a frame, the sync table still counts it as
|
||||
missing here and *Download* fetches and drops it each time; a photo never hashed whose
|
||||
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.
|
||||
|
||||
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,
|
||||
under the smallest of their SHA-256s; a deletion on either side covers every encoding. Linking
|
||||
a local sequence to a server one by content and the proxies this PC sends follow them (a frame
|
||||
this PC converted makes the proxy of the server's original). A download for a frame flagged
|
||||
missing here whose photo the server holds only in another encoding puts that file in the
|
||||
frame's place (the same id, nothing to the trash, a replaced tombstone linking the two), after
|
||||
the transfers and only in the folder the index has for the sequence, and queues the passes the
|
||||
swap cleared; a frame that changed meanwhile keeps its place and the copy is dropped.
|
||||
|
||||
Folders moved by another program (amended 2026-10-26, R7). When a desktop and a server share
|
||||
an archive, a Reorganize by one index (or a folder moved by hand) is found by the other's next
|
||||
scan, which moves the sequence's row, its frames and the paths of the exports that moved with
|
||||
@@ -1705,6 +1943,34 @@ Reorganize (amended 2026-10-26, R7), the panel's way to the Reorganize of §12.5
|
||||
audit log and the Dashboard read "… reorganized the archive · N sequences · M files renamed
|
||||
· templates".
|
||||
|
||||
Convert (amended 2026-10-26, R7), the panel's way to the Convert of §12.5 through
|
||||
`POST /archive/convert` (§14.3):
|
||||
- The Library's selection bar has *Convert…*, after *Reorganize…*, for the same selection: up
|
||||
to 1,000 sequences, or every sequence after *Select all* without a filter (one plan, one job).
|
||||
- The dialog: Format (JPEG, TIFF-16, Linear DNG, the archival choice, chosen first), Quality
|
||||
(JPEG only, 1–100, 95) and Mode (Replace or New sequence), never preselected; each choice's
|
||||
tooltip says what becomes of the originals. Each change asks the server for a dry run, one at
|
||||
a time (400 ms after typing the quality). Until a mode is chosen it is asked in Replace's
|
||||
words; New sequence asks again, answered from the plan the server keeps. The table shows each
|
||||
sequence, 200 at a time: photos converted, those left as they are with why (what blocks the
|
||||
whole sequence first; *Not copied* with New sequence) and the size before → after; then the
|
||||
totals and the server's space line. A dry run a proxy cut off is asked again every 2 s for up
|
||||
to 16 minutes, the totals saying how long it takes.
|
||||
- The dialog's *Convert…* (enabled while the table is the plan of the fields, converts
|
||||
something, has the space and a mode is chosen; its tooltip says what is missing) asks a
|
||||
Replace to type the word "replace" in the panel's language, and confirms a New sequence with
|
||||
how many photos the new sequences lack, each sequence listed with its own count. It then
|
||||
asks the dry run again (Close stays: nothing is sent yet) and sends that plan's fingerprint
|
||||
only while it is the one confirmed; the toast offers *Open job*. `plan_changed`,
|
||||
`plan_dropped`, `not_enough_space` and `nothing_to_convert` show the new plan and the button
|
||||
waits; a request that got no answer is not sent again, as its job may be queued (the Jobs
|
||||
page says).
|
||||
- The trash view lists replaced originals as *Replaced*, whose *Restore* swaps the originals back
|
||||
in place of their conversions while those are unchanged, else restores them into a new
|
||||
sequence. *Empty…* lists first the entries whose conversion was deleted, each saying so.
|
||||
- The audit log and the Dashboard read "… queued a conversion · N sequences · M photos ·
|
||||
format · mode".
|
||||
|
||||
Upload (amended 2026-10-26, R3): Library › *Upload* (no sequence) and a sequence's *Add
|
||||
photos* open the upload dialog (§14.4), a module the pages import only on demand.
|
||||
- Target: the given sequence, or a choice between an existing sequence (a search box, then a
|
||||
@@ -1743,7 +2009,8 @@ at first login), `CHRONOS_ARCHIVE_PATH=/archive`, `CHRONOS_DATA_PATH=/data`,
|
||||
`CHRONOS_SPACE_PATH` (`SpacePath` in `server.json`; optional: a folder, e.g. `/space`, whose
|
||||
volume's free space the admin panel shows instead of the archive's; one that cannot be
|
||||
measured falls back to the archive's with one warning, logged at start and again only once
|
||||
it has worked in between; uploads always check the archive's own volume, §14.4),
|
||||
it has worked in between; uploads always check the archive's own volume, §14.4, and a
|
||||
conversion the tighter of the two, §14.3: amended 2026-10-26, R7),
|
||||
`CHRONOS_DB=postgres|sqlite` (Linux: postgres only), `CHRONOS_DB_HOST`, `CHRONOS_DB_PORT=5432`,
|
||||
`CHRONOS_DB_NAME`, `CHRONOS_DB_USER`, `CHRONOS_DB_PASSWORD`, `CHRONOS_DB_SSLMODE=prefer`,
|
||||
`CHRONOS_HTTP_PORT=8080`, `CHRONOS_HTTPS_PORT=8443`, `CHRONOS_TLS_MODE=auto|pem|proxy`,
|
||||
@@ -2209,6 +2476,7 @@ questions asked and the answers; DECISIONS rows give the reasons.
|
||||
| 2026-10-26 | Owner review 2, R3 | §14.3, §14.4, §14.8 | Upload from the admin panel into an existing or a new sequence (file picker, drag and drop, no folders), hashed in the browser by a self-tested in-house SHA-256 in a module worker, the capture time read from Exif, sent in resumable chunks through the upload API and verified by the server; `server/info` lists the photo extensions; hidden dot files are refused for every client. |
|
||||
| 2026-10-26 | Owner review 2, R7 (Reorganize) | §5, §7, §12.2, §12.5, §12.8, §14.3, §14.5, §14.8 | Reorganize on the desktop (Archive manager, Library, the toast of Settings › Archive) and the admin panel (Library, the toast of Archive): folder, file and title templates applied to sequences already filed, behind a dry run that lists each sequence's changes, the photos that keep their names and why (in place outside `originals/`, never hashed, missing) and the sequences that stay whole (unreadable sidecar); applied by the `move` job of exactly the confirmed plan (fingerprint), which holds the rest when paused, cancelled or failed and lets a sequence still receiving photos keep its file names; crash-safe plan and file journals (two-phase renames through hidden temporary names, recovery by the next writer); a sequence of the plan left as it was inside a moving folder goes with it; the index, frames and exports follow a moved folder in one transaction, on this index and at another index's next scan; writers take the folder under the lease, never create a left one again and never write into a folder another sequence took; `POST /api/v1/archive/reorganize` with a kept, bounded plan cache and `sequenceChanged` `reorganized`; Rename… and Move… replaced. |
|
||||
| 2026-10-26 | Owner review 2, R7 (naming) | §7.1, §13, §14.3 | One naming rule for import, upload and Reorganize: the sequence's camera and lens, `{n}` its place, a frame without a time at the sequence's start; template rules everywhere a template is typed or sent (no folder level scans skip, one a value such as a title gives escaped with `_`; a file template keeps the extension, tells photos apart, holds no slash; long names shortened before `.{ext}`; titles as text), held to a template only when it is given anew; `invalid_template` names the rule. |
|
||||
| 2026-10-26 | Owner review 2, R7 (conversion) | §5, §7, §8.1, §8.3, §8.7, §9, §12.2, §12.4, §12.5, §13, §14.3, §14.4, §14.5, §14.8, §14.9 | Convert after import on the desktop (the Archive manager's set, the Library's selection) and the admin panel (the Library's selection): JPEG with a quality, TIFF-16 or linear DNG (the archival choice, scene-referred so a RAW's highlights above white and colours outside sRGB survive), Replace or New sequence chosen at every run and never remembered, behind a dry run that lists each sequence's photos, sizes and the photos that stay as they are with why, and the free space where the conversion writes; Replace confirmed by typing; the `convert` job (stored as 19) converts exactly the photos confirmed, one sequence at a time and all or nothing, resumable through its journals and staging, never twice at once; full-resolution decodes only (the managed decoders first, never a 16-bit file from an 8-bit RAW development; the server leaves what it cannot read to a PC), colour profiles kept, Exif carried, every file verified by the server's decoders; Replace swaps the files of the frames in place under a crash-safe journal, the originals going into a replaced trash entry that Undo or Restore swaps back and that Empty erases only while the archive on disk shows each conversion intact, or deleted; import still copies byte for byte and the card keeps a converted photo's copy; sync and the ingest count every encoding of a photo as one; `POST /api/v1/archive/convert` with the plan cache it shares with Reorganize, `sequenceChanged` `converted` and `created`, the audit `archive_converted`. |
|
||||
|
||||
## Appendix A — `CLAUDE.md` content (create verbatim in Phase 0, keep updated)
|
||||
|
||||
|
||||
@@ -5,6 +5,95 @@ commits follow Conventional Commits (release notes are generated from them by `C
|
||||
|
||||
## [Unreleased]
|
||||
|
||||
## [0.1.0-rc.7] — 2026-11-02
|
||||
|
||||
### Added
|
||||
- **Convert** on the desktop and the admin panel (owner review 2, R7): convert the photos of sequences already in the
|
||||
archive to JPEG (with a quality), 16-bit TIFF or linear DNG, the archival choice. At every run you choose what
|
||||
becomes of the originals: *Replace* (the converted files become the sequence's photos, the same frames, and the
|
||||
originals go to the archive's trash, from which *Undo* or *Restore* brings them back until the trash is emptied) or
|
||||
*New sequence* (converted copies in a new sequence beside each one, titled "… (DNG)", with its tags, rating, notes
|
||||
and project; the originals stay as they are). No mode is preselected and none is remembered.
|
||||
- A dry run first, following your choices: per sequence the photos converted, their size before and the estimate
|
||||
after, the photos that stay as they are and why (already in that format, a format this computer cannot read at full
|
||||
resolution, which the server answers with "convert these photos on a PC", read only from a preview, a RAW this
|
||||
computer develops at 8 bits only, a colour profile the format cannot keep, too large, unreadable, missing, never
|
||||
verified, held open by another program), the sequences left as they are (busy, offline, unreadable) and the free
|
||||
space the conversion needs. With New sequence it says which photos each new sequence lacks. Replace asks you to type
|
||||
the number of photos (desktop) or the word "replace" (admin panel); New sequence asks a confirmation that counts the
|
||||
photos not copied.
|
||||
- A *Convert* job then converts exactly the photos the dry run listed, one sequence at a time and all or nothing:
|
||||
photos uploaded meanwhile stay as they are, and a sequence whose photos changed since is left as it is and named in
|
||||
the job's log. Pause, resume and retry it in Jobs: it keeps what it converted, resumes after a crash, checks the
|
||||
free space as it goes and stops before the volume fills. A second conversion of the same sequences is refused while
|
||||
the first waits or runs.
|
||||
- Every photo is decoded at full resolution only, never from an embedded preview, by Chronos' own decoders wherever
|
||||
they read it (RAWs developed at full precision, the same on every computer), and keeps its colour profile and its
|
||||
metadata (capture time to the tick, camera, lens, exposure, GPS); every converted file is read back and decoded by
|
||||
the server's decoders before it is kept. A linear DNG keeps a RAW's highlights above white (up to 4 stops, in
|
||||
BaselineExposure) and its colours outside sRGB (ProPhoto primaries).
|
||||
- Desktop: *Convert…* in the Archive manager's set bar and in the Library's mass bar (the sequences of one archive).
|
||||
When a Replace job ends, its toast offers *Undo*, which brings back the originals that job replaced.
|
||||
- Admin panel: *Convert…* in the Library's selection bar (up to 1,000 sequences, or every sequence after *Select all*
|
||||
without a filter), and a toast that opens the job. A dry run that takes longer than a proxy lets a request last is
|
||||
asked again until it is ready.
|
||||
- The archive's trash lists the originals a conversion replaced as their own kind: *Restore* puts them back in place
|
||||
of their conversions while those are unchanged (the conversions then go to the trash), otherwise as a new sequence.
|
||||
*Empty…* erases them only while each conversion still matches where the archive holds it now; originals whose
|
||||
conversion was deleted are named first in its confirmation ("conversion deleted"), since they may be the last copy
|
||||
of their photos.
|
||||
- API v1: `POST /api/v1/archive/convert` (archive administrators): a dry run with the plan, its space line and its
|
||||
fingerprint, then the `convert` job (202) of exactly that plan; 409 `plan_changed`, `nothing_to_convert`,
|
||||
`not_enough_space`; 503 `plan_dropped` when the server let the plan go. The server keeps a dry run a few minutes,
|
||||
in the plan cache Reorganize uses. `sequenceChanged` with the changes `converted` and `created`; trash entries of
|
||||
kind `replaced`, and `conversionDeleted` in an emptying's dry run; the audit log and the Dashboard name
|
||||
conversions.
|
||||
- Known limitations: a photo that cannot be converted although the dry run listed it (a damaged RAW whose headers read
|
||||
well) leaves its whole sequence as it was, while the other sequences convert, and the job's retry fails the same
|
||||
way; a decode larger than the computer's memory stops the job itself at every retry, before the sequences after it
|
||||
(converted photos are capped at 268 MP for JPEG and about 179 MP for TIFF-16 and DNG, which makes it rare); on a PC,
|
||||
WIC decodes a TIFF whose compression it does not know as a black picture without an error, so such a file converts
|
||||
to black (with Replace, *Undo* or *Restore* brings the original back until the trash is emptied), and a file only
|
||||
WIC reads whose size the index does not know is found too large only when it converts; a damaged file that still
|
||||
decodes (a truncated TIFF strip, a corrupt JPEG scan) converts as the partial picture its decoder gives; a PNG's
|
||||
gamma and primaries without an embedded profile, JPEG XL, JPEG XR, BMP and GIF, and Exif colour spaces other than
|
||||
sRGB, Adobe RGB and uncalibrated are taken as sRGB; a linear DNG keeps the as-shot white balance baked in and
|
||||
clips noise below black; MakerNote and XMP are not carried; the server's kept dry run does not see a change made on
|
||||
disk alone (a photo another program held stays listed as held for up to 5 minutes, unless the index changes), and
|
||||
the job then converts only the photos the dry run listed, each only while it holds the content confirmed; a
|
||||
conversion of every sequence of an archive that keeps receiving uploads may never be confirmed, as each upload
|
||||
changes the plan; of two confirmations of the same sequences at once the second is refused with `plan_changed`;
|
||||
an emptying's dry run lists as erasable an entry the job then keeps (its conversion changed or cannot be located,
|
||||
its sequence busy), and the job says why and fails at the end; erasing replaced originals holds their sequence while
|
||||
every conversion is re-hashed; the desktop's *Undo* lives in the toast of the job's end only: later, after a
|
||||
restart, or for a conversion the server ran, *Restore* in the trash brings the originals back.
|
||||
|
||||
### Changed
|
||||
- Import still copies every photo byte for byte and converts nothing. Deleting imported photos from a card keeps, and
|
||||
formatting the card refuses, a photo converted since: its archived file no longer matches the card.
|
||||
- Sync and imports count a photo and its conversion as one photo: a photo converted on either side, or on both,
|
||||
compares as one; importing a card or a folder again, or downloading an original, files nothing for a photo
|
||||
converted since; an upload of such an original into its sequence is answered `alreadyExists`; *Download originals*
|
||||
puts the server's conversion in place of a photo missing here, instead of adding a frame.
|
||||
- Exif written by Chronos (proxies, exports, converted photos) includes the exposure program, metering mode, flash
|
||||
and white balance when known.
|
||||
- Server: Reorganize's and Convert's dry runs share one plan cache, two made at once and eight kept across both.
|
||||
- Emptying the trash says in its job log why it kept each entry: changed after the plan, its sequence busy, a
|
||||
conversion that no longer matches, or one that cannot be located (scan the archive).
|
||||
- Desktop: a confirmation with a long list scrolls it, so its buttons stay on screen.
|
||||
- **Upgrade:** there is no migration: the index stays at schema 8, and earlier versions keep the sidecar fields
|
||||
conversions write (`frames[].source`, tombstones of reason `replaced`). Undo conversions before going back to an
|
||||
older version: it cannot swap replaced originals back (its *Restore* keeps them in the trash) nor settle a
|
||||
replacement a crash interrupted.
|
||||
|
||||
### Fixed
|
||||
- The managed TIFF decoder (the server's, and the desktop's after WIC) read CMYK, CIELab and palette TIFFs as the gray
|
||||
of their first channel; it now leaves them unreadable (a PC reads them through WIC). A TIFF with an impossible
|
||||
number of strips or tiles is refused as unreadable too, so a PC asks WIC, instead of failing with an arithmetic
|
||||
error.
|
||||
- Sync's job log lines (a photo missing, changed, deleted on this PC or on the server, frames without a proxy or
|
||||
thumbnail on the server) are in your language; they were English in every language.
|
||||
|
||||
## [0.1.0-rc.6] — 2026-10-27
|
||||
|
||||
### Added
|
||||
|
||||
+30
-4
@@ -148,7 +148,7 @@ One line per decision: date · decision · alternative · reason.
|
||||
| 2026-10-03 | Editor 1:1 and wheel zoom render at the source's long edge, Fit at the view's size; labelled preview tools (icon + text) with full screen, play and the crop view icon-only; the shot-data pill moves above the tools when they do not fit at 1200 px. | Render only the visible region | Decoders decode whole frames; simplest correct option. |
|
||||
| 2026-10-03 | Export tab: preset grid columns = width / 200 px; Output label column fixed at 96 px with ellipsis and tooltip; Optimise all skips Stack; render follow-ups are a toast with Show in folder plus the history line's show-file link. User presets ("Customise") are not built; the Export "Sync" box is (2026-10-06: ExportSettings.SyncToServer, off by default). | Fixed 4 columns / placeholder controls | The fixed grid clipped at 1200 px; user presets need a preset store and render-path resolution. |
|
||||
| 2026-10-03 | Exposure measuring tool switches Luminance / Flicker (frame-to-frame log-luminance change before and after correction) / Waveform (luma per column band of the corrected preview); the Time tab shows a plan chart beside the remap curve; the Camera free crop is four margin sliders (≤ 45 % each, ≥ 10 % of the frame left). | One chart per tab | §12.3 measuring needs and Editor.html. |
|
||||
| 2026-10-03 | Import omits the Convert row and the profile "New" button: card profiles are born on first insertion and shared through camera profiles (settings row followed by the cards of that camera; a card without settings joins automatically). | Conversion at import / card-less profiles | A converted file breaks the hash-verified erase/format gate and immutable originals; a profile needs a card identity (§13 "rules shared by all cards of that camera"). |
|
||||
| 2026-10-03 | (Partly superseded by the 2026-10-26 conversion after import row: import still copies byte for byte and has no Convert row; converting is a separate, explicit step after import, which keeps the erase gate and the originals.) Import omits the Convert row and the profile "New" button: card profiles are born on first insertion and shared through camera profiles (settings row followed by the cards of that camera; a card without settings joins automatically). | Conversion at import / card-less profiles | A converted file breaks the hash-verified erase/format gate and immutable originals; a profile needs a card identity (§13 "rules shared by all cards of that camera"). |
|
||||
| 2026-10-03 | Import sessions merge in the session table and split per photo in Show plan (merges only into the earlier session of the same body and format). Folder and Server destinations run in the screen with a partial result on failure; a server 4xx (not 401/403) fails only that file. Automatic import always goes to this PC's archive. | New job kinds / abort on any error | No job handlers exist for those destinations; §13 lists errors per file; the archive is the gated destination for erase/format. |
|
||||
| 2026-10-03 | Format gate: every photo on the card must be verified by the job's own import records; non-photo files are listed in the typed confirmation, not blocking; the card is re-listed right before SHFormatDrive, behind a typed confirmation of the card name; a card that leaves needs a new check. | Count only DCIM photos / block on any file | Sony and Canon cards always carry camera files; §8.6 and DESIGN §4. |
|
||||
| 2026-10-03 | (Partly superseded by the 2026-10-26 Reorganize job row: a plan its job paused, cancelled or failed is left to that job, not completed at the next open.) Archive manager: Overview (tree, tiles, charts, mass operations on the tree selection narrowed by a Camera/Status/Tag filter) and Maintenance (health with one fix per line, recent runs, duplicates, orphans); duplicates/orphans searches and retag run in-screen, cancellable and logged; rename apply is journaled and completed at the next open; Maintenance adds a database backup. No Merge/split yet (Delete… and Trash… exist since 2026-10-06, through the engine's trash). | Engine jobs for every action / Archive.html's single page | No result store for read-only reports; deleting or moving frames needs engine operations (the trash lives in the server). |
|
||||
@@ -480,12 +480,12 @@ One line per decision: date · decision · alternative · reason.
|
||||
| 2026-10-26 | Tombstones are the sidecar's `removed` list (left out when empty, kept by older builds), copied into `frame_removals` (migration 0008) at every index sync without the content a frame of the sidecar holds again, and gone with the sequence row. A deletion writes one only for a SHA-256 no photo that stays holds. They outlive emptying the trash; a deleted sequence's record keeps them for a restore whose folder lost its sidecar, and a sidecar rebuilt from the photos takes the index's back. Filing that content into the sequence again (an import, a restore, an explicit upload again) drops its tombstone. (Owner review 2, R6.) | Tombstones in the index only, or in the trash records | A rebuild from the sidecars keeps them; a duplicate that stays was not removed; an emptied trash must not let sync bring the photo back. |
|
||||
| 2026-10-26 | Photos never hashed are hashed as they go, for their tombstone. Frames that stay are looked at only when never hashed and of a deleted photo's size: a SHA-256 of their first and last 64 KiB is compared first, the whole file is read only when those match, and the full hash is kept in the sidecar and the index. A dry run blocks a never-hashed original that is on disk but cannot be read (409 `photo_unreadable`; it opens at most 256 of them, and the deletion's own hashing refuses one past those as `folder_in_use`, nothing moved). Known limitation: a never-hashed photo whose original is already missing is deleted without a file and without a tombstone (its record stays, a restore reports `no_file`, Empty erases it), so a copy elsewhere can come back; the edge prints are not stored, so N such originals of one size cost 128 KiB × N reads per deletion until a verify hashes them. (Owner review 2, R6.) | Refuse to delete a photo without a hash; hash every frame that stays | A file that is gone has no content to name, and blocking it would make it undeletable; reading only likely twins keeps a deletion among raw files quick. |
|
||||
| 2026-10-26 | When indexed frames vanish from a sidecar (a deletion here, or by another process sharing the archive), `ProjectPositions` translates the project's positions by photo: those on the photos that went wait as pending frames and come back with a restore, the others follow their photos, and the settings version stays; a hero frame id whose frame is gone is cleared. A deletion or restore clears light and deep analysis, thumbnails and proxies in the sidecar and the row and queues them again: light analysis always, deep analysis at background priority when the sequence had one, thumbnails and proxies always on the server and on the desktop when it had them. Proxies are renamed and `thumbs.pack` re-keyed (`ThumbPackWriter.Rekey`, skipped while a thumbnail pass holds the pack) to follow their frames, and the server's thumbnail locator checks the fingerprint of never-hashed frames too. (Owner review 2, R6.) | Keep positions as they were (the earlier rule); rebuild every proxy and thumbnail | Exclusions, the hero and keyframes must not slide onto other photos; proxies and thumbnails are keyed by index, so moving them lets the passes reuse them and never shows a neighbour's thumbnail. |
|
||||
| 2026-10-26 | Emptying the trash is only an explicit job behind a dry run and a fingerprint. The dry run measures each entry on disk; the fingerprint is the SHA-256 of `kind\|name\|files\|bytes\|deletedAt ticks` per entry, in name order. The `EmptyTrash` job (stored as 18, user priority, normal level in the priority queue) keeps each entry's name and fingerprint: at its start any change of the plan erases nothing, a resumed job checks each remaining entry alone, and under its lease each entry is read and measured again and kept if it changed; an entry moves into `trash/.erasing` and is then deleted, leftovers going at the next emptying; a `replaced` entry goes only while its replacements still match their SHA-256 (re-hashed); a kept entry fails the job at the end. No schedule and no clean-up step empties the trash. The desktop asks for the number of entries to be typed, the panel for the word "empty" in its language. (Owner review 2, R6; BRIEF §0.2 rule 8.) | Erase in the request; a scheduled or age-based emptying | The only erase of user files must be an explicit, confirmed, verified and resumable action that erases exactly what the user saw. |
|
||||
| 2026-10-26 | (Partly superseded by the 2026-10-26 replaced entries emptying row: a `replaced` entry is weighed against the archive on disk, a conversion deleted since is said in the dry run and its fingerprint, and a kept entry is logged with why.) Emptying the trash is only an explicit job behind a dry run and a fingerprint. The dry run measures each entry on disk; the fingerprint is the SHA-256 of `kind\|name\|files\|bytes\|deletedAt ticks` per entry, in name order. The `EmptyTrash` job (stored as 18, user priority, normal level in the priority queue) keeps each entry's name and fingerprint: at its start any change of the plan erases nothing, a resumed job checks each remaining entry alone, and under its lease each entry is read and measured again and kept if it changed; an entry moves into `trash/.erasing` and is then deleted, leftovers going at the next emptying; a `replaced` entry goes only while its replacements still match their SHA-256 (re-hashed); a kept entry fails the job at the end. No schedule and no clean-up step empties the trash. The desktop asks for the number of entries to be typed, the panel for the word "empty" in its language. (Owner review 2, R6; BRIEF §0.2 rule 8.) | Erase in the request; a scheduled or age-based emptying | The only erase of user files must be an explicit, confirmed, verified and resumable action that erases exactly what the user saw. |
|
||||
| 2026-10-26 | Trash API under ManageArchive. Entry names are `<id>[-<time>[-n]]` (a sequence) or `photos-<id>-<time>[-n]`, and the API takes only that shape, never a path. Offline, the listing and the emptying answer 503 `archive_offline` (the erase also when read-only). 422 `trash_mismatch` is for an entry none of whose files matches its record, or a sequence entry whose own sidecar no longer names it; 409 `sidecar_mismatch` for a damaged or foreign sidecar of the sequence the photos return to (also on `frames/delete`, and on sequence deletes that settle a journal first). The emptying request is audited `trash_empty_requested` (entries, bytes, names, the job); what was erased is in the job's log. (Owner review 2, R6.) | Names with `/`; an empty listing when offline; audit `trash_emptied` at the request, or from the job | A single URL segment rules out path traversal; an unreachable archive is not an empty trash; an audit entry must not claim an erase the job may still refuse, and the job has no hook into the server's audit. |
|
||||
| 2026-10-26 | `POST /sequences/{id}/frames/delete` needs the Delete permission and the owner or an admin, like `DELETE /sequences/{id}`; each block has its code (`frames_conflict`, with the frames version now, only for changed frames; `sequence_busy`, `would_empty`, `photo_unreadable`, `archive_offline`), and it takes 1–100,000 ids under its own body limit (`FrameDeleteBodyLimit`, 100,000 × 48 + 4096 bytes, about 4.8 MB) set as routing metadata like the proxy route's: a third exception to the 2026-10-02 1 MiB rule, after chunks and proxies. (Owner review 2, R6.) | Lower the id limit to about 20,000 | A sequence of 100,000 photos must be able to lose most of them in one request; the 1 MiB limit stopped at about 26,900 ids. |
|
||||
| 2026-10-26 | Bulk routes take 1–1,000 distinct ids per request and answer each id in order, `ok` or `skipped` with the code and its sentence: delete moves each sequence whole as `DELETE /sequences/{id}` does (another user's is `forbidden` unless the caller is an admin), retag is the PATCH tag edit with up to 3 attempts on a conflict, and jobs queue one job at user priority. A verify of sequences targets their archive with the sequences in its parameters (`ArchiveJobs.Verify`), which also fixes `POST /jobs` with `verify`, whose job failed at once. The panel sends 1,000 ids a request (one job per 1,000 sequences, the toast counting them), lists every page of a filter for *Select all*, and refreshes every loaded row 1,000 a request. (Owner review 2, R6.) | No limit; a server-side "all of the filter" selection | Bounded requests and answers; the same rules as the single-sequence endpoints. |
|
||||
| 2026-10-26 | Uploads keep deleted photos out: a start whose SHA-256 the target sequence tombstoned answers `alreadyExists` without a frame id, unless a frame of the target still holds that content (a stale tombstone refuses no repair); the completion checks again after the upload stops receiving, and the ingest a third time under the sequence's lease, which a deletion takes (`IngestRequest.RefuseRemoved`), answering 409 `photo_removed` with the upload cancelled and its files deleted (`ChronosClient` returns null for it). Only an explicit user action brings such a photo back: `StartUploadRequest.Restore` and `complete?restore=true` (a query, so the uploads table needs no migration), sent by the panel's *Upload again* on a *Deleted before* row between runs, never by sync, the Uploader or a card import; with it no stand-in in another sequence counts, and filing the photo drops its tombstone, also after Empty. The desktop has no such path. (Owner review 2, R3, R6.) | Check at start only; store the flag on the upload; only a restore from the trash brings a photo back | An old client syncing a copy, or a watch folder, must not undo a deletion, and no deletion may land between the last check and the commit; a user who uploads a photo again on purpose means it, also once the trash is emptied. |
|
||||
| 2026-10-26 | Sync tombstones: a `deleted` tombstone keeps the photo from being offered to the side that deleted it (no upload of what the server deleted, no download of what this PC deleted); a `replaced` one is an alias, followed up to 8 steps, compared, transferred and translated as the replacement. A tombstone leaves a photo out only while its side holds no matching photo (by hash, or by size and capture time while unhashed). An unhashed server frame is fetched, hashed and dropped when this PC deleted it; an unhashed local frame the server deleted is not sent, and the archive verify then runs so the next comparison leaves it out. Positions parked for a photo the other copy deleted stay pending; sync never deletes local files. Known limitation: until the server verifies such a frame, the row counts it as missing here and *Download* fetches and drops it each time (fixing it needs size and capture time in the tombstones). (Owner review 2, R6.) | Drop parked positions; delete the local copy; tombstones by size and time now | A deletion on one side is not undone by the other, neither side loses a file, and a restore places the parked positions again. |
|
||||
| 2026-10-26 | (Partly superseded by the 2026-10-26 sync aliases row: `replaced` tombstones of both sides join encodings of one photo, compared as the smallest SHA-256 among them, with no step limit.) Sync tombstones: a `deleted` tombstone keeps the photo from being offered to the side that deleted it (no upload of what the server deleted, no download of what this PC deleted); a `replaced` one is an alias, followed up to 8 steps, compared, transferred and translated as the replacement. A tombstone leaves a photo out only while its side holds no matching photo (by hash, or by size and capture time while unhashed). An unhashed server frame is fetched, hashed and dropped when this PC deleted it; an unhashed local frame the server deleted is not sent, and the archive verify then runs so the next comparison leaves it out. Positions parked for a photo the other copy deleted stay pending; sync never deletes local files. Known limitation: until the server verifies such a frame, the row counts it as missing here and *Download* fetches and drops it each time (fixing it needs size and capture time in the tombstones). (Owner review 2, R6.) | Drop parked positions; delete the local copy; tombstones by size and time now | A deletion on one side is not undone by the other, neither side loses a file, and a restore places the parked positions again. |
|
||||
| 2026-10-26 | The server refuses frame uploads whose file name starts with `.` (400 `invalid_file_name`) from every client, and the panel's dialog counts such files as not photos. (Owner review 2, R3.) | Leave them to each client | The archive scanner leaves hidden files out, so an upload must not file what an import of the same folder would not; the AppleDouble `._` files a Mac leaves on cards were filed through the server import before. |
|
||||
| 2026-10-26 | The panel's Library is the second sidebar entry, with the Image icon (the Dashboard keeps the four tiles of the mockup). The trash is a view of the Library (`#/library?view=trash`, `pages/library/trash.js`) that Archive opens with a *Trash* button. The upload dialog is a module the Library and a sequence import on demand (`import("../upload.js")`, exporting `openUpload({ api, sequence, onDone })`); a test checks that nothing imports it statically and, lexing every admin module, that each top-level function that uses `api` takes it. (Owner review 2, R6, R3.) | A Trash panel inside Archive; static imports | One route and module reachable from both places, beside the deletions that fill it; other pages never load the upload code; CI has no JavaScript engine, so a structural check catches an out-of-scope `api` like the one that broke every web upload during this phase. |
|
||||
| 2026-10-26 | New `GET /api/v1/sequences/facets` (years newest first, camera models most used first with `PathTemplate.CameraName` as their label, tags by key with their first spelling, each with its count, from the server archive's rows) and `rendered=true\|false` on `GET /sequences`. Covers come from `GET /sequences/{id}/thumb` (the hero's thumbnail, else the first frame's; `private, max-age=3600`, ETag) at `?v=<hero>-<framesVersion>`. (Owner review 2, R6.) | Menus built from the loaded page; no cover endpoint | The menus must offer exactly the values the filters take without reading every sequence; a new cover or other photos change the address, while edits of title, tags or rating keep the cached image. |
|
||||
@@ -518,7 +518,33 @@ One line per decision: date · decision · alternative · reason.
|
||||
| 2026-10-26 | A sequence keeps its folder when it already is what the template gives, or that name with the " (n)" filing or an earlier Reorganize gave it, in the template's case; a change of case only is planned while no other folder holds that exact name (another sequence's, or on a case-sensitive file system a folder on disk beside the sequence's own: `RenamePlanner.ExistsExactly` compares every level exactly) and moves through a temporary name. No two sequences of a plan get folders that differ only in case. Under the step's leases a case-only target that now exists beside the sequence's own folder refuses the step (dropped when resuming), as `MoveFolder` would; a change of case in an outer level moves on every file system. (Owner review 2, R7.) | Compare folder names without case; make every target unique again | A second Reorganize must plan nothing (a folder flipped between " (2)" and " (3)" before); NTFS ignores case and Linux does not; a plan that fails at every archive open must never be journaled. |
|
||||
| 2026-10-26 | Template rules (`TemplateRules`, checked on three sample photos two seconds apart): a folder template may not write a level scans never enter (`ReservedFolder`: starting with `.`, or `originals`, `proxies`, `exports`, `.chronos`); a file template may hold no slash (`FileSeparator`), must keep the photo's extension (`Extension`: `PathTemplate.KeepsExtension`, the extension appended or after `.{ext}`) and must give a session's photos different names (`NotUnique`). What a template does not write itself is made safe instead: a folder level a title gives that scans skip gets a leading `_` (`ExpandFolder`, for import, upload and Reorganize alike), a file name over 200 characters is shortened before its `.{ext}` without splitting a surrogate pair, and a title template expands as text (`ExpandText`: control characters as spaces, at most 200 characters, no file-name sanitizing). Each rule has its sentence (`Errors.Template.<Rule>`). (Owner review 2, R7.) | Check only that a template parses | `{n}{ext}` drops the dot, and with it the extension every decoder goes by; a folder scans skip vanishes from a rebuilt index; repeating names fill a session with `_2`, `_3`; titles became `Paris_ night`. |
|
||||
| 2026-10-26 | The rules hold wherever a template is typed or sent: the desktop's Settings › Archive, Import and Reorganize fields (`NamingPreview`), the server's Reorganize and `PUT /archive/settings`, and the archive engine (`ArchiveSettings.Problem`, `CheckTemplates`). A template `archive.json` already holds (saved by 0.1.0-rc.5 or earlier) is held to them only when an edit changes it: the engine's `UpdateSettingsAsync` and the server's PUT check the rules only for templates that differ from the stored ones, every template still having to be non-blank, valid and expandable (the PUT compares with the archive as the server last read `archive.json`; when that file changed since, a desktop's edit say, and the engine refuses a template the form still sends, the answer is still `invalid_template` with the rule, never 409 `archive_policy`); `CreateAsync`, and so adopting a new folder, holds both to every rule (this PC's templates saved by an older version then refuse Welcome › Create, the toast naming the rule, fixed in Settings › Archive). A broken rule is a `TemplateRuleException` (an `ArgumentException` naming the field, with the rule), whose sentence the desktop's toasts show; the API's `invalid_template` details are `<field>:<rule>` (`fileTemplate:extension`) with that sentence in the request's language, a blank or invalid template keeping the bare field and the generic message. (Owner review 2, R7.) | Refuse every save while a stored template breaks a rule; check the rules in the user interfaces only | A pre-rules template must not block an edit of the name, the proxy size or the other template, on the desktop or the panel; neither the engine nor the server accepts from another client what the fields refuse. |
|
||||
| 2026-10-26 | The server keeps Reorganize dry runs (`ReorganizePlanCache`), keyed by the archive, the selection (all, or the ids in their order), the templates and `SequenceRepository.GetStampAsync`: a SHA-256 of what the planner reads from the index (every row's id and folder; for the planned rows their title, first capture, camera make and model, lens, photo count, frames version and how many of their photos are hashed; for others inside a planned folder their title). Uploads into other sequences, ingest status writes, verifies of other sequences and tag or note edits keep a plan; a verify that hashed planned photos plans again. A plan, or a refusal (`nested_target`, `not_found`), is kept 5 minutes from when it was made (a timer per plan, checked again on access); failures and stopped plans are not. Plans are made apart from the request (a request cut off only stops waiting), once per key, at most 2 at once (`Concurrency`) and 8 kept or being made (`Capacity`: a new one lets go the kept plan asked for first, else the one being made asked for first, which stops); one still being made 15 minutes after it was asked (`PlanTimeout`, the wait for a turn included), let go, or running when the server stops is cancelled and answered 503 `plan_dropped`. The confirmation forgets its key once the job is queued. (Owner review 2, R7.) | Plan again at every request; plan in a background job with progress | An `all` dry run reads every sidecar and photo folder, minutes over SMB, and behind a proxy's timeout it was never shown; the job plans again and compares fingerprints, so a kept plan that is stale can only fail, never change what the dry run did not show (a change made on disk alone answers 202, then the job fails changing nothing). |
|
||||
| 2026-10-26 | (Partly superseded by the 2026-10-26 conversion plan cache row: `ReorganizePlanCache` is `PlanCache`, shared with Convert, its 2 at once and 8 kept counting both kinds.) The server keeps Reorganize dry runs (`ReorganizePlanCache`), keyed by the archive, the selection (all, or the ids in their order), the templates and `SequenceRepository.GetStampAsync`: a SHA-256 of what the planner reads from the index (every row's id and folder; for the planned rows their title, first capture, camera make and model, lens, photo count, frames version and how many of their photos are hashed; for others inside a planned folder their title). Uploads into other sequences, ingest status writes, verifies of other sequences and tag or note edits keep a plan; a verify that hashed planned photos plans again. A plan, or a refusal (`nested_target`, `not_found`), is kept 5 minutes from when it was made (a timer per plan, checked again on access); failures and stopped plans are not. Plans are made apart from the request (a request cut off only stops waiting), once per key, at most 2 at once (`Concurrency`) and 8 kept or being made (`Capacity`: a new one lets go the kept plan asked for first, else the one being made asked for first, which stops); one still being made 15 minutes after it was asked (`PlanTimeout`, the wait for a turn included), let go, or running when the server stops is cancelled and answered 503 `plan_dropped`. The confirmation forgets its key once the job is queued. (Owner review 2, R7.) | Plan again at every request; plan in a background job with progress | An `all` dry run reads every sidecar and photo folder, minutes over SMB, and behind a proxy's timeout it was never shown; the job plans again and compares fingerprints, so a kept plan that is stale can only fail, never change what the dry run did not show (a change made on disk alone answers 202, then the job fails changing nothing). |
|
||||
| 2026-10-26 | `POST /api/v1/archive/reorganize` (ManageArchive): exactly one of `sequenceIds` (1–1,000) and `all`, a null template kept, at least one given; a dry run answers the plan (`ReorganizePlanDto`: steps with folders, titles, carried, frames version, file count, up to 3 samples and what stays, its reason in snake case with a sentence in the request's language; totals; fingerprint); the change answers 202 with the `move` job. 400 `bad_request` (`sequenceIds`, `templates`, `fingerprint`), `invalid_template`; 404 `not_found` (`sequence`); 409 `nested_target` (details: the folder), `plan_changed` (details: the fingerprint now), `job_unavailable`; 503 `archive_offline`, `plan_dropped`. Audited `archive_reorganized` ("sequences · files · folder, file and title templates"), which the panel's audit log and Dashboard show as a sentence. (Owner review 2, R7.) | Separate rename and move endpoints; every planned name in the answer | One request carries the three templates as both programs do; a dry run of 100,000 photos answers counts and samples, not every name. |
|
||||
| 2026-10-26 | Panel: the Library's *Reorganize…* sends the selected ids, up to 1,000, and `all: true` only above that while the selection is exactly *Select all* without a filter and the total has not changed; any other larger selection is refused with a toast, never split into several plans or jobs. The dialog's switches start on for the parts with a template (Titles off and empty, the archive having no title template; from the Archive page's toast only the changed parts), templates are sent trimmed, a dry run runs 400 ms after typing (Enter at once) with one request in flight and a change meanwhile planned right after, an older request's refusal is not shown, and Apply runs only while the shown plan is the fields' and changes a sequence. The confirmation has two buttons and asks for nothing typed (nothing is deleted); a different plan answered during it is shown, not applied. `toast(message, isError, action)` takes an optional link or button; such toasts stay 15 s and pause under the pointer or the keyboard focus. (Owner review 2, R7.) | Split a large selection into several jobs; a typed confirmation | One dialog is one plan and one job, and separate plans could give two sequences one destination; a typed word is for what cannot be undone. |
|
||||
| 2026-10-26 | Desktop: one *Reorganize…* dialog replaces Rename… and Move… of the Archive manager and Move… of the Library, for the sequences of one archive as Move was: Folders and File names on with the archive's templates (read again from the index when it opens), Titles off with `{title}`; the dry run follows the typing (400 ms; Enter or leaving a field plans at once unless that dry run is on screen or under way, so a click on Apply is never turned off under it), and only the latest dry run publishes its result. After Settings › Archive saves a new folder or file template into an archive with sequences, a toast offers *Reorganize…* for every sequence with the changed parts on, one offer per archive, a change made while its toast is up (8 s) joining it (`ReorganizeOffer`, `Toast.Closed`); on the Archive screen an open dialog is never replaced: Reorganize waits, says so, and opens when it closes. The old Rename and Move keys were pruned from every language (`i18n prune`); the capture scene is `archive-reorganize-*`. (Owner review 2, R7.) | Keep Rename (titles) beside Reorganize; a modal question or an automatic Reorganize after a template change | One concept and one button for how filed sequences are named, with the same three templates as the panel; templates only name what is filed next, so a toast offers without interrupting and nothing moves without the dry run; a new key shows as untranslated instead of 36 languages keeping "Move". |
|
||||
| 2026-10-26 | Conversion after import: import still copies every photo byte for byte and has no Convert row (the 2026-10-03 row stands for import). Converting is *Convert…*, an explicit step after import, on the desktop (the Archive manager's set, the Library's selection of one archive) and the admin panel (the Library's selection: up to 1,000 sequences, or every sequence after *Select all* without a filter), through one engine (`MassConverter`) and one job, behind a dry run. Replace only moves originals into the archive's trash and New sequence leaves them where they are: nothing rewrites an original. The card erase gate still re-hashes the card file and the archived copy against the import hash, so a converted photo keeps its card copy (`CopyMismatch`) and a format is refused while it is on the card. (Owner review 2, R7.) | Convert at import (the sketch's row); convert originals in place | The owner asked for conversion after import as well; the hash-verified erase and format gate and immutable originals hold because no original is rewritten and a card is never erased against a converted file. |
|
||||
| 2026-10-26 | Replace or New sequence is chosen at every run and never remembered: both dialogs open with no mode and Apply waits for one, asked last, after what converts and the space; Format starts on Linear DNG (`ConvertOptions.ArchivalTarget`) and Quality on 95, nothing kept in settings. What converts does not depend on the mode, so the desktop plans once per format and quality and sets the mode on that plan, and the panel asks its preview in Replace's words (`mode: replace`) and asks again for New sequence, answered from the plan the server keeps; the fingerprint names the mode. A Replace is typed: the desktop asks for the number of photos it replaces (as Delete and Empty ask for a count), the panel for the localised word "replace" (as Empty asks for "empty"); New sequence asks a plain confirmation that says how many photos the new sequences lack. (Owner review 2, R7.) | Remember the last format and mode; default to Replace; a typed confirmation for both modes | The owner's answer: a choice at every run; a remembered Replace would be one Enter away; each program keeps its own typed confirmation for what moves originals into the trash, and New sequence changes no original. |
|
||||
| 2026-10-26 | Targets: JPEG baseline 4:4:4 with optimised Huffman tables, 8-bit, quality 1–100 (default 95); TIFF 16-bit RGB with Deflate and the horizontal predictor; linear DNG (16-bit LinearRaw, lossless JPEG tiles, UniqueCameraModel "Chronos"), the archival default. A conversion's DNG is scene-referred (`LinearDngOptions.SceneReferred`): the pixels are stored in linear ProPhoto (ROMM) primaries, divided by the smallest power of two that brings their peak under 0.998 of white, at most 2^4 (`LinearDngWriter.MaxHeadroomStops`), BaselineExposure giving those stops back; ColorMatrix1 and ForwardMatrix1 describe ProPhoto with illuminant D65 and AsShotNeutral 1/1/1, and the encode matrix is the inverse of the in-house reader's solve of the rationals written, so a file reads back as written to the 16-bit step. The as-shot white balance is baked in and values below 0 are clipped. Exports keep the clipped linear-sRGB DNG. (Owner review 2, R7.) | A float DNG; a fixed 4× headroom; the export's clipped linear sRGB for conversions too | Once the trash is emptied a Replace's file is the photo: the highlights a RAW develops above white (about a stop on a partly clipped sky) and its colours outside sRGB (negative in sRGB primaries) must survive; 16-bit integers are what every raw editor reads, and a power of two keeps the steps exact; an export is a rendered picture whose highlights the render decided, and its files stay as earlier builds made them. |
|
||||
| 2026-10-26 | A conversion decodes at full resolution only (`AllowPreview: false`, upright) through its own chain (`FrameConverter.Decoders`): the managed provider first, so every format it reads natively is developed in-house at float precision, as on the server, and the host's others (WIC) after it for what it cannot read (a CR3, a HEIC, a CMYK TIFF). For TIFF-16 and linear DNG a RAW never goes through a provider that develops at 8 bits (`IImageDecoderProvider.DevelopsRawAt8Bits`, true for WIC's Raw Image Extension): such a RAW is planned out as `eight_bit`, refused at conversion (`ConversionFailure.EightBit`) and converts to JPEG only. The conversion's managed provider reads JPEG, PNG and TIFF headers when it probes (`ManagedDecoderProvider.ReadsHeaders`): what its decoders refuse there (a compression, sample format or photometric they lack, more than `MaxSamples` or `MaxPixels`, arithmetic coding, a JPEG or PNG larger than one array) is asked of WIC on a PC and is `convert_on_pc` on the server. The archive engine's other decodes keep WIC first on the desktop. (Owner review 2, R7.) | The archive engine's order (WIC first); develop RAWs at 8 bits for every target | The Raw Image Extension gives 24bppRGB, too few bits for a 16-bit archival file, and the in-house developer gives the same pixels on every host; the dry run must promise only what the decoders it uses take. |
|
||||
| 2026-10-26 | The managed TIFF reader refuses, before reading pixels, samples it does not render (`TiffImageReader.Renders`): CMYK (5), CIELab (8), palette (3), LogL/LogLuv, RGB of fewer than three samples and float min-is-white, for every managed decode; strip and tile counts are counted in 64 bits and impossible ones refused as data (`InvalidDataException`), and `ReadInfo` refuses what a decode would. On the server such a frame is unavailable instead of the gray of its first plane; a conversion on a PC reads it through WIC. (Owner review 2, R7.) | Decode them as gray, as before | With the managed decoders first, a Replace would have put a gray or black picture in the archive and the original into the trash; an `OverflowException` escaped the decoder chain, which then never asked WIC. |
|
||||
| 2026-10-26 | Colour profiles: `SourceColor` reads what a photo's headers record (JPEG APP2 chunks, PNG iCCP or sRGB, TIFF tag 34675 from the image the decoders read, then IFD0, then Exif, HEIF/AVIF `colr` prof, rICC or nclx, WebP ICCP, Exif ColorSpace with Interop) and whether its samples are linear (a float or LinearRaw TIFF), and `FrameConverter.Treatment` keeps that space. JPEG and TIFF-16 carry the ICC profile (APP2 chunks, tag 34675) with code values unchanged, linear values coded with the profile's own curves; linear DNG takes the values converted to linear Rec.709 through a matrix/TRC profile (linear values through the matrix alone, unclipped); an sRGB profile, told by its numbers for matrix/TRC (matrix within 2e-3 of identity, curves within 2e-3 of the sRGB curve) and by its name only for a lookup-table profile, needs nothing in a DNG; a gray profile converts to sRGB. Exif uncalibrated with Interop R03 (or ColorSpace 2) gets an in-house v2.1 "Compatible with Adobe RGB (1998)" profile, a HEIF nclx box with P3 primaries "Display P3". Refused as `color_profile`: CMYK, Lab and other non-RGB profiles, a lookup-table profile into a DNG or holding linear values, curves that cannot be inverted, uncalibrated without R03, other nclx primaries or an HDR transfer, a profile that does not parse; colorants that convert nothing (no positive Bradford cone response, a non-finite or singular matrix) are dropped when parsed, so such a profile is carried into JPEG or TIFF and refused for DNG. PNG gAMA/cHRM without iCCP, JPEG XL, JPEG XR, BMP, GIF and other Exif ColorSpace values are read as sRGB. (Owner review 2, R7.) | Drop profiles and write the values as sRGB (the first version); convert everything to sRGB; refuse every photo that is not sRGB | A Replace makes the converted file the photo: a Display P3 HEIC or an Adobe RGB JPEG must keep its colours; carrying the profile keeps a JPEG's or TIFF's values exact, and a DNG's colour is its matrices, so it takes converted values. |
|
||||
| 2026-10-26 | A converted file's Exif (`FrameConverter.Metadata`, `ExifWriter`): from the sidecar the capture time to the tick, offset, exposure, f-number, ISO, focal length, bias and white balance; from the original the make, model, serial, lens, 35 mm focal length, exposure program, metering mode, flash, GPS, artist and copyright, the sequence's camera and lens where the original names none; a frame without a capture time keeps the original's Exif or XMP time, never one from the file system; orientation 1 (the pixels are upright), Software "Chronos"; no MakerNote or XMP. `ExifWriter` now writes ExposureProgram, MeteringMode, Flash and WhiteBalance, for proxies and exports too. (Owner review 2, R7.) | Copy the original's Exif block whole | The sidecar's times are the archive's, and the verify checks them to the tick; MakerNote offsets do not survive a new layout; an upright picture written with its old orientation would turn twice. |
|
||||
| 2026-10-26 | The dry run promises only what the job does (`ConvertPlanner.Skip`): every frame is asked with the conversion's decoders whatever tier was recorded (unknown before the light analysis, another host's, a preview), headers only, 8 files at a time per sequence, and its colour headers are read. Skip reasons: `SameFormat` (the target's format already: any TIFF for TIFF-16, any DNG for linear DNG), `Missing`, `Unhashed`, `Undecodable` (flagged, or a file shorter than its own headers), `TooLarge`, `NoNativeDecoder` and `PreviewOnly` (both `convert_on_pc` on the server), `EightBit`, `ColorProfile` and `Inaccessible` (an I/O error or denied access other than not found: a file another program holds without sharing). `TooLarge` is a bound, never an estimate: a JPEG side above 65535, more than the server's decoders read back (a JPEG of 2^28 pixels, a TIFF-16 or DNG of 2^29 samples), or an incompressible worst case (51 bits per pixel, plus 1 %, plus 8 MiB for a profile and headers) above one array; a `MemoryStream` overflow while encoding is `TooLarge` too. (Owner review 2, R7.) | Probe only frames recorded below native tier (the first version); count a held file as missing | A conversion the dry run promised that then failed made its whole sequence fail at every retry; a lock released before the job ran let it convert, with Replace, a photo the confirmed plan said stays. |
|
||||
| 2026-10-26 | A `convert` job converts exactly the photos its confirmed plan listed: each `ConvertSequence` of its parameters carries the frames version, the digest of the photos converted (`ConvertSequencePlan.Digest`: a SHA-256 over `{frameId:N}\|{sha256}` per photo, in sidecar order) and their frame ids (`Photos`, 16 bytes each in base64), and the plan's fingerprint covers the digests. Under the sequence's lease, its sidecar settled where the index has it then, the job plans it again and takes the confirmed photos from that plan, going on only while they have the digest confirmed; it then pins them (`journal/convert-<job>.pins`, `PinLog`) and from then on, a retry included, converts those alone, stage B checking under the lease that every pinned photo still holds its content, not the frames version. Photos uploaded or verified after the confirmation stay as they are. A confirmed photo that changed, went or no longer converts leaves the sequence as it is (`Changed`: its retry leaves it too, and the log says to plan again); one another program holds leaves it for the retry (`Blocked`), and a held photo the job does not convert hides no real change. A job an earlier build queued without photos checks the whole plan's digest, or the frames version. (Owner review 2, R7.) | Plan again and convert what the job finds (the first version); hold the frames version; store the whole plan in the job | The change made is the one shown and typed (BRIEF §0.2 rule 8); a time-lapse still receiving uploads must not make its sequence unconvertible at every retry; 16 bytes a photo keep a whole-archive job row small. |
|
||||
| 2026-10-26 | The job takes one sequence at a time, its stage A then its stage B. Stage A runs without the lease: each original is re-hashed against its record (a mismatch fails the photo: verify the sequence), converted and verified into `.chronos/staging/convert-<job>/<sequence>/`, as many at once as `DecodeBudget` allows for the parallelism and memory, each staged file appended to `journal/convert-<job>.staged` (one JSON line, flushed). Stage B is all or nothing under the sequence's lease. `journal/convert-<job>.json` records each sequence's outcome, the statuses its passes follow from and whether they were queued: the passes are queued as soon as a sequence is journaled, and a resume queues those a pause, a yield or a crash lost. A resumed job first settles the crash journals of the sequences still to do, and takes one its replacement already completed (by the pins, or without them by the frames' `source` against the digest) as converted. A photo that fails fails its sequence, whose staged files stay for the retry, which verifies and takes them; the other sequences go on, and the job fails at the end. A sequence another index moved away (`SequenceFolders.Holds`) is left blocked with `Errors.Archive.FolderMoved`; New sequence reads the source's project under the source's lease and writes the copy's under the copy's, only into a folder that holds it. A sequence's staging goes once it is final or changed, the job's journals and staging once every sequence is final. (Owner review 2, R7.) | All of stage A first, then all of stage B; one JSON journal rewritten per photo; delete the staging of a sequence that failed | Results appear earlier and less is staged at once; appending keeps journaling linear on an 80,000-frame sequence, where a rewritten journal is quadratic; a retry keeps the work done. |
|
||||
| 2026-10-26 | Maintenance (`ArchiveMaintenance.PurgeTemporaryFilesAsync`) keeps a `convert-<job>` staging folder while its job is queued, running or paused, whatever its age, removes it at once when the job is done, and otherwise once its files are a day idle; a conversion's journal files go when its job is done. A job this index does not know (another host's on a shared archive, or one its history forgot) keeps its staging and journal together while any of their files was written within `CleanupSteps.DefaultHistoryDays` (90), then both go; staging without a journal goes after a day idle. (Owner review 2, R7.) | Purge staging by age alone (24 h) | A stage A longer than a day lost its staged files, and another host's paused or failed job would have converted everything again; nothing this purges is an original. |
|
||||
| 2026-10-26 | Free space is measured where a conversion writes: `ArchiveServiceOptions.FreeSpace` for the archive root and for its staging folder, the tighter kept. The server takes `VolumeSpace.WritableFree`, the tighter of the space path's volume (R2) and the folder's own (on Unraid the cache, until the mover runs); the desktop asks Windows (`VolumeInfo.FreeBytesAt`, `GetDiskFreeSpaceEx`), which measures UNC archives too. A conversion needs its estimate × 1.15 plus a 512 MiB reserve, counted in both modes (Replace keeps the originals in the trash), estimated from the Export tab's bits per pixel (JPEG by quality × 1.25 for 4:4:4, TIFF-16 30, linear DNG 26; 24 MP when the size is unknown). The job checks at its start, before each sequence (every estimate not staged yet) and before each photo (that photo and those after it that may convert at once, fewer near the end), its estimates scaled by how far the files staged in this run came out above theirs; short, it stops with `Archive.Error.ConvertSpace` (in GB, or MB below one), its journal and staging kept for the retry. The server measures again at every dry run and confirmation. (Owner review 2, R7.) | The space volume alone, as the panel shows it; one check per job | On Unraid every staged and filed byte lands on the cache; the noise of a 14-bit RAW outgrows the estimate; a job must stop before the volume fills, not after; reserving a whole batch near the end stopped jobs that fitted. |
|
||||
| 2026-10-26 | No conversion of the same sequences twice: `MassConverter.QueueAsync` checks the queued, running and paused `convert` jobs and queues under one lock of the process, calling the host's enqueue in the caller's context (the desktop's speaks on its UI thread); a sequence another conversion holds refuses the plan (`ConversionQueuedException`, `Archive.Convert.AlreadyQueued`): 409 `plan_changed` without details on the server, and the desktop plans again, showing those sequences busy. A dry run counts every pending conversion's sequences as busy; a job's own re-plan counts only those of conversions created before it (`JobRepository.ListPendingTargetsAsync(kind, createdBefore)`). (Owner review 2, R7.) | Let the second job find the first | Two dialogs or tabs, a lost answer and Apply again, or a dry run made before the first job was queued would make two new sequences or convert twice. |
|
||||
| 2026-10-26 | New sequence: the copies are filed through the archive ingest under the session key `convert:<job>:<source>` (a resume finds the same sequence), titled "<title> (JPEG\|TIFF\|DNG)", in a folder from the archive's template, named as the ingest names every photo (`StagedFrame.NamedAs`: `{name}` the card name, `{ext}` the target's), with the source frames' capture time, offset, time source and intervalometer flag; the source's tags, rating, notes and project (positions translated by photo) follow, and its owner is the source's, else the requesting user's id. It holds the converted copies alone: the photos a sequence it copies skips are not in it (their positions wait as pending frames); the dry run says *not copied* for them (`Archive.Convert.NotCopied.*`, `Server.Convert.OnPcNew`; a sequence that converts nothing gets no copy and keeps "stay as they are"), the panel's totals and confirmation and the desktop's summary and New sequence confirmation count them, and the job log says how many stayed in the source alone (`Archive.Log.ConvertLeftOut`). A copy no longer staged at stage B fails the sequence before anything is filed. (Owner review 2, R7.) | File the photos that do not convert byte for byte into the copy; leave the skipped photos unsaid | A copy of mixed formats would be neither a conversion nor the original and would double the bytes of photos that did not change; saying before the confirmation what a copy lacks keeps it from being found missing later. |
|
||||
| 2026-10-26 | Replace swaps the files of frames in place (`FrameTrash.ReplaceAsync`): the same ids and indices, so the project's positions stay (translated by the sidecar's own photo for every frame still there, also when the index was stale). Each converted file is named as filing names a photo of the sequence (`ConvertOptions.FileName`: the archive's file template, the frame's `FrameNaming` context, `{ext}` the target's in lower case, a long name shortened before its extension), unique among every file present and every name the sidecar held, those leaving included, so nothing is moved onto a file (a stray `Roof_01.dng` keeps its bytes, the conversion becomes `Roof_01_2.dng`); a sequence named by an older template takes the current one's names. Each original and its XMP companions go into one replaced trash entry per sequence and run, whose record holds the old frame records, each replacement's SHA-256, a copy of `analysis.json` and the job's id. The new record keeps the flags the user and the capture set and takes the file's own (missing, corrupt, duplicate, preview-only, undecodable) from the conversion, with a `source` naming the original; the sidecar clears the statuses the frames covered and gains a replaced tombstone per original. The proxies of the swapped frames are deleted and normal passes queued (light analysis, a background deep analysis when it had one, thumbnails, proxies). (Owner review 2, R7.) | Give the converted files the old names; one trash entry per photo; force the proxy pass | Every reference to a frame stays valid and the undo is exact; a crash between two moves is undone without doubt when no incoming file took a leaving one's place; a proxy is reused by capture time, which a conversion keeps, so stale proxies must go, and forcing would remake frames that were not converted. |
|
||||
| 2026-10-26 | A replacement's journal, `.chronos/replace.pending.json`, is written under the sequence's lease before the first move, the new entry's record staying pending until the sidecar is written; it records a phase (`Moving`, `Written`, `Undoing`) and each swapped frame's new name. The next writer (`SequenceWriter.ReadLocked`) completes a replacement that is `Written`, or `Moving` with the sidecar listing a new name (by content, never by the frames version, which any writer moves), and undoes any other, which stays `Undoing`; a failed inline rollback marks `Undoing` and rethrows, and an undo that fails during recovery stops the writer, as a photo deletion's recovery does. Every writer that changes frames settles it first (`FrameTrash.EnsureReplaced`: the ingest, deletions, restores, Reorganize steps, sequence deletion, which wait while it cannot settle yet), and a scan settles it and reconciles nothing in the folder while it stays. A journal without names, from an earlier build, still decides by the frames version. (Owner review 2, R7.) | Decide by the frames version (the first version) | An upload landing after a failed undo could make the recovery complete a swap that never happened; what the sidecar lists tells whether it was written. |
|
||||
| 2026-10-26 | Undo is restoring the replaced entry. While every converted frame still holds its conversion (re-hashed) and names the original as its `source`, the originals swap back through `FrameTrash.ReplaceAsync` (same ids; the converted files into a replaced entry in turn, without a job id; the entry's copy of `analysis.json` back into the sequence); otherwise they come back as a new sequence, and an entry left without photos drops its analysis copy. The desktop's toast of a finished Replace (all its endings Replace conversions, none failed) offers *Undo*, once and never from the Windows notification, which restores exactly the replaced entries that job made (`PhotoTrashRecord.JobId`, `TrashEntry.JobId`), oldest first; a failed Replace keeps its Retry; later, after a restart and on the panel, the trash's *Restore* does the same. (Owner review 2, R7.) | Refuse the restore when frames changed; find the job's entries by time window (the first version); record the entries in the job | Nothing is ever lost and the API stays one call; the job's id is exact where a time window could take the entry of converted files a restore made meanwhile; a failed conversion usually needs its retry. |
|
||||
| 2026-10-26 | Replaced entries emptying: an emptying weighs a replaced entry against the archive on disk, never this host's index alone (`SequenceTrash.Replaced`). Its sequence is found by its sidecar (in the folder the index has, in the one the entry recorded, in its deleted folders in the trash, else by walking the archive's folders; each sidecar indexed once per survey) and followed through its replaced tombstones (up to 8 links), and each conversion must still hash to its SHA-256 where it is. A conversion counts as deleted only when the sidecar shows it (a deleted tombstone at the end of the chain, or the frame gone while every frame is hashed and no photo of the folder is unlisted), when the sequence is in the trash, or when no sidecar of it exists and the index has no row; the dry run then marks the entry `ConversionDeleted` (part of its fingerprint), every copy the trash still holds must hash to the conversion, and with none left the confirmed emptying erases it. The erase holds the entry's lease and the sequence's: it settles the sequence first (an undo waiting for the entry completes), reads, measures and fingerprints the entry again, then surveys and re-hashes. Kept, each with its log line (`TrashKeptReason`): changed after the plan, its sequence busy, a conversion that no longer matches (also a frame whose file changed since), a conversion the archive cannot locate (scan the archive). (Owner review 2, R7.) | Decide from this index (fix round 1); keep such entries for ever (the first version) | A conversion another host made, or one this index had not read yet, would be taken for deleted and its originals erased without re-hashing it; when a conversion really is gone, the originals may be the last copy and must be erasable on purpose, never by mistake. |
|
||||
| 2026-10-26 | Every entry that may hold the last copy of its photos is shown with why before the typed confirmation: the desktop's *Empty…* names every `ConversionDeleted` entry first ("conversion deleted"), wherever the newest-first trash lists it, the others filling the six lines and the rest counted, and a confirmation's detail scrolls past 288 px; the panel lists those entries first, each saying so. (Owner review 2, R7.) | The six newest entries, as for every other confirmation | The number typed must follow a look at what may be lost for good, however old the conversion is. |
|
||||
| 2026-10-26 | Sync aliases: `SyncTombstones` takes every replaced tombstone of either side as a link between two encodings of one photo and joins them (union-find); each SHA-256 compares as the ordinal-smallest of its photo's, whatever the order of the links, so a conversion, a conversion of it, its undo and each side converting its own copy stay one photo; a deletion on either side covers every encoding. It is immutable once made, so parallel transfers share it. (Owner review 2, R7.) | One alias per original, followed up to 8 steps (R6) | Converting on both sides made duplicate frames on both. |
|
||||
| 2026-10-26 | Linking by content (`SyncService.SameOriginalsAsync`), the proxies this PC can send (`SyncRules.ProxiesToSend`, `SyncTransfers.SendProxiesAsync`: a frame this PC converted makes the proxy of the server's original) and downloads follow the aliases. A download for a frame flagged missing here whose photo the server holds only in another encoding (neither its own encoding there nor an intact frame of it here) puts the verified copy in that frame's place (`FrameTrash.ReplaceMissingAsync`: the same id, nothing to the trash, the record read from the file with the old one as its `source`, a replaced tombstone), after the transfers and only once the sequence is in the folder the index has, else the copies stay staged and the job fails with the folder-moved error; each swap queues the passes it cleared, those already queued skipped; a frame that changed meanwhile keeps its place, and the copy is dropped and logged. The job log lines of uploads and downloads are resources. (Owner review 2, R7.) | File the other encoding as a frame of its own | No photo is doubled and none stays missing. |
|
||||
| 2026-10-26 | The ingest answers content a replaced tombstone of the sequence names, followed through later conversions to an intact frame, as a duplicate of that frame and keeps the tombstone: a card or a folder imported again, a download of the original, an upload sent with `restore`; once no replacement is intact, the original is filed again. An upload without `restore` is still answered as deleted (R6). The ingest settles a restore and a replacement of the sequence first and files nothing while one cannot settle (`LeaseUnavailableException`; an upload's client tries again). The card erase still keeps the card copy, the bytes differing. (Owner review 2, R7.) | File the original again beside its conversion, as before | Importing a card again would double every converted photo and drop the link that makes sync count both as one; frames must not be filed beside a swap no writer has settled. |
|
||||
| 2026-10-26 | Conversion plan cache: `ReorganizePlanCache` becomes `PlanCache`, one singleton for Reorganize and Convert with typed keys (`PlanKey<TPlan>`: `ReorganizePlanKey`, `ConvertPlanKey`, each naming the exceptions that are refusals, `ArgumentException` for Convert): 2 plans made at once and 8 kept across both kinds, 15 minutes to make one, 5 minutes kept, else 503 `plan_dropped`. `ConvertPlanKey` is the archive, `SequenceRepository.GetConvertStampAsync` (the Reorganize stamp and, per planned sequence, its photos' count and sums of sizes, formats, widths and heights, with how many are flagged missing, corrupt, preview-only or undecodable), the sequences (`*`, or the ids in order) and the target with its effective quality (0 for a lossless target); not the mode, which the request sets on the kept plan with its options. The busy sequences and the free space are taken again at every request; a plan made while the archive was offline is not kept (503 `archive_offline`). A confirmation takes only the plan kept for the index as it is now (`PlanCache.Kept`), else answers 503 `plan_dropped` at once, never planning inside its own request; `plan_changed` means the kept plan differs (a job made a sequence busy or free, or a conversion was queued). The panel asks a cut-off dry run again (504 or 524, or no answer or 502 after 20 s) every 2 s for up to 16 minutes and a dropped one once; its Apply asks the dry run again first (Close and Esc stay), confirms only the same fingerprint and retries `plan_dropped` once; an apply with no answer is never sent again. (Owner review 2, R7.) | Plan inside every request (the first version); plan inside a confirmation that finds no kept plan | Behind a proxy a conversion of every sequence could get past neither its dry run nor its apply; a confirmation cut off after its job was queued would invite a second job. |
|
||||
| 2026-10-26 | `POST /api/v1/archive/convert` (ManageArchive): exactly one of `sequenceIds` (1–1,000) and `all`; `target` `jpeg`, `tiff16` or `linear-dng` (any case); `quality` 1–100 (default 95, checked for every target, counted for a JPEG; the panel sends null for the others); `mode` `replace` or `new-sequence`; `dryRun`; and the `fingerprint` that confirms. A dry run answers `ConvertPlanDto` (target, quality and mode; a step per sequence asked with its photos, bytes before and after, skips with their wire reason and sentence, and blocks; the totals; the space with its line; the fingerprint), `NoNativeDecoder` and `PreviewOnly` sharing the wire name `convert_on_pc`. The change answers 202 with the job, labelled with its sequence's title when it converts one, else with the archive's name. 400 `bad_request` (`sequenceIds`, `target`, `quality`, `mode`, `fingerprint`); 404 `not_found` (`sequence`); 409 `plan_changed`, `nothing_to_convert`, `not_enough_space` (details: the bytes needed), `job_unavailable`; 503 `archive_offline`, `plan_dropped`. Audited `archive_converted` ("sequences · photos · target · mode"), which the panel's log and Dashboard show as a sentence. Trash entries of kind `replaced`, and `TrashEntryDto.conversionDeleted` in an emptying's dry run. (Owner review 2, R7.) | One endpoint per mode; every photo of the plan in its answer | One request carries the choices both programs make, as Reorganize's does; a dry run of 100,000 photos answers counts and reasons, not every photo. |
|
||||
| 2026-10-26 | Mass conversion is a job on both hosts: `JobKind.Convert` (stored 19, wire `convert`, labelled *Convert*), user priority, the normal level in the priority queue (listed on both hosts), its targets the sequences (deletions and other writers see them busy while it runs or is paused, and an archive-wide job, a paused Reorganize among them, holds it back), handled by `ConvertJobHandler` through `ArchiveService.CreateJobHandlers`; progress counts photos and the checkpoint only marks a resume (the journal says where). Each sequence is told as it completes, `sequenceChanged` `converted` (frames replaced) or `created` (the new sequence), and a desktop editor open on it reloads; the desktop announces its end (`JobNotices`), and the Library reads the sequences again once it ends done or failed. (Owner review 2, R7.) | Target the archive; reuse the `move` kind | Only the sequences converted wait; a failed conversion converted the others; a job is paused, resumed after a restart and followed in Jobs on both hosts. |
|
||||
| 2026-10-26 | Conversion failures read as one catalog sentence by cause (BRIEF §0.2 rule 6): `ConversionException` carries a `ConversionFailure` (`NoDecoder`, `PreviewOnly`, `EightBit`, `ColorProfile`, `TooLarge`, `NotVerified`, `Changed`), which `FrameConverter.FailureText` turns into `Archive.Convert.Failed.<reason>`, as it turns a full disk (Windows HResults, ENOSPC on Linux), a denied access, undecodable data, other I/O and anything else into theirs. The job log reads "Left as it was: <title>. <file> could not be converted. <reason>" (`Archive.Log.ConvertFailed`, `Archive.Convert.PhotoFailed`), a stage B failure `Archive.Convert.NotPlaced`, a blocked sequence its reason (folder moved, photo held, sidecar unreadable, access, lease busy); the exception's English text goes to the diagnostics log only. (Owner review 2, R7.) | The exception's text in the job log (the first version) | Every string the user reads is a resource, and the technical text names internals the user cannot act on. |
|
||||
+16
-13
@@ -16,7 +16,7 @@ by its `windows` job once a Windows runner is registered (`WINDOWS_RUNNER`), and
|
||||
| 8 Release readiness | Release pipeline end to end (installers, portable and server zips, SHA256SUMS, release notes, optional signing, server image in the Gitea container registry, optional separate releases repository), update check with verified download, scrubbed diagnostics bundles (desktop and server), performance gates, 38 cultures (`en`, `it` and 36 machine translations with glossaries and independent reviews), RTL pass (`ar`, `he`: mirrored windows, left-to-right islands for media, charts, numbers and paths; any right-to-left culture added later follows), accessibility pass (names, live regions, keyboard paths for charts and the curve editor). The installer test (silent install of the packed installers, run, upgrade in place, uninstall: files, Add/Remove Programs, shortcuts, file type, user data kept, exit codes) runs in CI's `windows` job on a Windows runner. Pending: the interactive install on a real PC, Unraid template validation on a real server. |
|
||||
| 8.1 Owner review 1 | In progress (request, answers and plan: `docs/requests/2026-10-15-owner-review-1.md`). Phase 1 done: stalled thumbnail and proxy jobs no longer fail and stay Running (frame-counted progress, bounded time left, final state always written); the editor's cancelled decodes stay in their tasks (no debugger stops in `WicDecoderProvider.cs`); WIC decodes RAW only through the Raw Image Extension and never DNG; GoPro DNGs converted by Adobe software are DNGs, developed natively for videos, read through their embedded preview for analyses and previews, and reclassified in existing archives by the next light analysis. Phase 2 done: jobs run one at a time on the desktop and the server; Parallelism is how many photos the running job processes at once (thumbnail and proxy passes, tier probes, deep analysis, render decodes); pausing the running job starts the next; an optional priority queue by job kind (Settings › Rendering, admin panel › Settings › Jobs, `CHRONOS_PRIORITY_QUEUE`) pauses lower jobs and resumes them by themselves; `CHRONOS_PARALLELISM` replaces `CHRONOS_WORKERS`. Phase 3a done: the rail is 200 px and collapses to icons with ≡ or Ctrl+B (tooltips then name the sections, the choice saved at once); the admin panel's sidebar is 256 px and collapses the same way. Phase 3b done: the Sequence section is now Edit, one sequence at a time chosen in a picker inside the section (Change sequence, Ctrl+O; the sequence edited last selected first), and the editor's tabs are the steps of a guided, freely navigable path from a new Analysis step (every finding with the step that deals with it) to Export, each step showing where it stands, with Previous and Next. Next, after owner review 2 (the owner's order): phase 4, the visual crop locked to the output's proportions (R5) and mirroring, 90° rotations, straightening and colour filters (R6). |
|
||||
| 8.2 Chronos on Gitea | Done (request: `docs/requests/2026-10-23-chronos-gitea.md`): Titano renamed Chronos everywhere, translations' grammar included; repository, update check, links, issue forms and registry moved to the self-hosted Gitea; Gitea Actions CI, release, nightly image and performance workflows for the Linux runner, with the Windows programs cross-compiled and checked (`pe-check`); new `Chronos.Tools` commands `zip`, `gitea-release`, `postgres-ci`, `pe-check`. Pre-releases `v0.1.0-rc.1` and `v0.1.0-rc.2` (the update check builds its links from `ChronosReleasesUrl`, since Gitea's use its LAN ROOT_URL) published; `REGISTRY_TOKEN` is set and the `v0.1.0-rc.2` server image is in the registry. |
|
||||
| 8.3 Owner review 2 | In progress (request, answers and plan: `docs/requests/2026-10-26-owner-review-2.md`). Phase 1 done and released as `v0.1.0-rc.3` (one adversarial review round, 19 findings fixed; strings in all 38 languages): `:latest` follows the highest stable release, or the highest pre-release while none is stable (`Chronos.Tools release-channels`), `:nightly` stays the nightly build of `main` (R1); `CHRONOS_SPACE_PATH` and the Unraid template's *Array view* (`/mnt/user0/<share>` read-only at `/space`) make the admin panel show the array's free space, the cache apart as *Write volume*, the file system in the tooltip, and completing an upload checks the archive volume first (507, resumable) (R2); the Settings icon is a toothed gear and the admin panel docks Settings at the foot of its sidebar (R4); About is the last page of Settings on the desktop and the last group of Settings on the admin panel (R5); Import › Folder… › *Whole folder* imports a folder as one sequence per format, titled after the folder (R9). Phase 2 done and released as `v0.1.0-rc.4` (one adversarial review round, 35 findings fixed; strings in all 38 languages): scheduled jobs (R10) — schedules (migration 0007) with an in-house recurrence form, one scheduler per host claiming runs by compare-and-set with catch-up, and Jobs › Scheduled on the desktop and the admin panel (`/api/v1/schedules`, `scheduleChanged`); every timer that queued work is a visible system schedule (server: archive scan, upload clean-up every 6 h, index backup at 03:00, job history and audit log clean-ups; desktop: archive scan, daily index backup, housekeeping with cache trim), the archive still scanned at start; new Backup and Clean-up jobs, duplicates and orphans reports as jobs, one backup retention, the trash only reported; log settings (R11) — file and console levels, retention, file and total size limits, daily or hourly rotation, audit retention (the audit clean-up schedule's) and the diagnostics share in the admin panel's Settings › Logs (`CHRONOS_LOG_*`, `lockedBy`) and the desktop's Settings › Advanced; the server's files take Debug and Trace again, and logging never fails a job. Phase 3 done and released as `v0.1.0-rc.5` (one adversarial review round and two fix rounds, 40 findings fixed; strings in all 38 languages; Library, photo delete and restore and the web upload tried by hand): the admin panel manages and never edits (R6) — a Library page (facets filters, cards or list, keyboard selection, mass Analyse, Proxies, Thumbnails, Verify, Tags, Export CSV and Delete, 1,000 sequences a request), a sequence's page (inline title, tags, rating, notes, photo viewer, cover, downloads, photo delete) and the trash view (Restore, Empty… behind a dry run, the typed word and a fingerprint); photos deleted into `trash/photos` under crash-safe journals with tombstones in the sidecar and `frame_removals` (migration 0008), so sync and uploads never bring them back unless restored or uploaded again on purpose; trash kinds, restore reasons and the `EmptyTrash` job on the desktop's Trash… too (typed entry count); the panel's files revalidated (`no-cache`, ETag); upload from the panel (R3) — file picker or drop, no folders, a self-tested in-house SHA-256 in a module worker, Exif capture time, resumable chunks. Known limitations: a never-hashed photo whose file was already missing is deleted without a tombstone; an unhashed server frame of a photo deleted on a PC stays *missing here* until the server verifies it; `jobState` carries no kind, so panel pages refresh after any job. Phase 4a done and released as `v0.1.0-rc.6` (one adversarial review round and six fix rounds; strings in all 38 languages): Reorganize after import (R7) on the desktop (Archive manager, Library, the toast after Settings › Archive templates change; it replaces Rename… and Move…) and the admin panel (Library, the *Saved* toast of Archive) — folder, file and title templates applied to filed sequences behind a dry run that lists every change, the photos that keep their names and why (in place, never verified, missing) and the sequences that stay whole (unreadable sidecar), applied by the `move` job of exactly the confirmed plan (fingerprint, `POST /api/v1/archive/reorganize`, plans kept a few minutes on the server), which holds the rest when paused, cancelled or failed (also while the archive is offline), lets a sequence still receiving photos keep its file names and takes along a sequence left as it was inside a folder that moves; files renamed in two phases under `.chronos/rename-files.json`, completed after a crash by the next writer; the index, frames and exports follow a moved folder in one transaction, here and at another index's next scan, and writers never create a folder a Reorganize left nor write into one another sequence took; import, upload and Reorganize name photos by one rule (the sequence's camera and lens), and templates follow one set of rules everLine truncated
|
||||
| 8.3 Owner review 2 | In progress (request, answers and plan: `docs/requests/2026-10-26-owner-review-2.md`). Phase 1 done and released as `v0.1.0-rc.3` (one adversarial review round, 19 findings fixed; strings in all 38 languages): `:latest` follows the highest stable release, or the highest pre-release while none is stable (`Chronos.Tools release-channels`), `:nightly` stays the nightly build of `main` (R1); `CHRONOS_SPACE_PATH` and the Unraid template's *Array view* (`/mnt/user0/<share>` read-only at `/space`) make the admin panel show the array's free space, the cache apart as *Write volume*, the file system in the tooltip, and completing an upload checks the archive volume first (507, resumable) (R2); the Settings icon is a toothed gear and the admin panel docks Settings at the foot of its sidebar (R4); About is the last page of Settings on the desktop and the last group of Settings on the admin panel (R5); Import › Folder… › *Whole folder* imports a folder as one sequence per format, titled after the folder (R9). Phase 2 done and released as `v0.1.0-rc.4` (one adversarial review round, 35 findings fixed; strings in all 38 languages): scheduled jobs (R10) — schedules (migration 0007) with an in-house recurrence form, one scheduler per host claiming runs by compare-and-set with catch-up, and Jobs › Scheduled on the desktop and the admin panel (`/api/v1/schedules`, `scheduleChanged`); every timer that queued work is a visible system schedule (server: archive scan, upload clean-up every 6 h, index backup at 03:00, job history and audit log clean-ups; desktop: archive scan, daily index backup, housekeeping with cache trim), the archive still scanned at start; new Backup and Clean-up jobs, duplicates and orphans reports as jobs, one backup retention, the trash only reported; log settings (R11) — file and console levels, retention, file and total size limits, daily or hourly rotation, audit retention (the audit clean-up schedule's) and the diagnostics share in the admin panel's Settings › Logs (`CHRONOS_LOG_*`, `lockedBy`) and the desktop's Settings › Advanced; the server's files take Debug and Trace again, and logging never fails a job. Phase 3 done and released as `v0.1.0-rc.5` (one adversarial review round and two fix rounds, 40 findings fixed; strings in all 38 languages; Library, photo delete and restore and the web upload tried by hand): the admin panel manages and never edits (R6) — a Library page (facets filters, cards or list, keyboard selection, mass Analyse, Proxies, Thumbnails, Verify, Tags, Export CSV and Delete, 1,000 sequences a request), a sequence's page (inline title, tags, rating, notes, photo viewer, cover, downloads, photo delete) and the trash view (Restore, Empty… behind a dry run, the typed word and a fingerprint); photos deleted into `trash/photos` under crash-safe journals with tombstones in the sidecar and `frame_removals` (migration 0008), so sync and uploads never bring them back unless restored or uploaded again on purpose; trash kinds, restore reasons and the `EmptyTrash` job on the desktop's Trash… too (typed entry count); the panel's files revalidated (`no-cache`, ETag); upload from the panel (R3) — file picker or drop, no folders, a self-tested in-house SHA-256 in a module worker, Exif capture time, resumable chunks. Known limitations: a never-hashed photo whose file was already missing is deleted without a tombstone; an unhashed server frame of a photo deleted on a PC stays *missing here* until the server verifies it; `jobState` carries no kind, so panel pages refresh after any job. Phase 4a done and released as `v0.1.0-rc.6` (one adversarial review round and six fix rounds; strings in all 38 languages): Reorganize after import (R7) on the desktop (Archive manager, Library, the toast after Settings › Archive templates change; it replaces Rename… and Move…) and the admin panel (Library, the *Saved* toast of Archive) — folder, file and title templates applied to filed sequences behind a dry run that lists every change, the photos that keep their names and why (in place, never verified, missing) and the sequences that stay whole (unreadable sidecar), applied by the `move` job of exactly the confirmed plan (fingerprint, `POST /api/v1/archive/reorganize`, plans kept a few minutes on the server), which holds the rest when paused, cancelled or failed (also while the archive is offline), lets a sequence still receiving photos keep its file names and takes along a sequence left as it was inside a folder that moves; files renamed in two phases under `.chronos/rename-files.json`, completed after a crash by the next writer; the index, frames and exports follow a moved folder in one transaction, here and at another index's next scan, and writers never create a folder a Reorganize left nor write into one another sequence took; import, upload and Reorganize name photos by one rule (the sequence's camera and lens), and templates follow one set of rules everLine truncated
|
||||
| 9 Monetization | Not started: requires explicit approval (§22). |
|
||||
|
||||
## Verification (2026-10-12)
|
||||
@@ -91,6 +91,10 @@ src/Chronos.App/bin/Release/net10.0-windows/Chronos.exe --capture out/screenshot
|
||||
change, and *Apply* queues the *Reorganize* job (pause and resume it in Jobs).
|
||||
Admin panel: Library › select sequences › *Reorganize…* › *Apply…* › *Reorganize* › *Open job*; or Archive › change
|
||||
the file template › *Save* › *Reorganize…* in the toast.
|
||||
- Convert: desktop Archive › select a year › *Convert…* › Linear DNG, *Replace* › *Apply* › type the number of photos ›
|
||||
*Replace*; when the job ends, *Undo* in its toast brings the originals back (later: Maintenance › *Trash…*).
|
||||
Admin panel: Library › select sequences › *Convert…* › JPEG, *New sequence* › *Convert…* › *Convert* › *Open job*:
|
||||
the copies appear as "… (JPEG)"; with *Replace*, type "replace", and the trash's *Restore* swaps the originals back.
|
||||
- Project files: Export › *Save project file* writes a `.chronos` file; opening it (double-click or `Chronos.exe <file>`)
|
||||
opens the sequence with those settings in the running Chronos.
|
||||
- Notifications: minimise Chronos and insert a card or finish a job: a Windows notification appears; Ctrl+1…6 and
|
||||
@@ -104,27 +108,26 @@ src/Chronos.App/bin/Release/net10.0-windows/Chronos.exe --capture out/screenshot
|
||||
Owner reviews, in the owner's order (owner review 2 first, then the rest of owner review 1); each phase ends with a
|
||||
release (owner review 2, R12):
|
||||
|
||||
1. Owner review 2, phase 4b: R7 mass conversion.
|
||||
2. Owner review 2, phase 5a: R8 workspace and projects with a local home (migration 0009).
|
||||
3. Owner review 2, phase 5b: R8 server home.
|
||||
4. Owner review 2, phase 5c: R8 originals, local render, clean-up, Workspace settings.
|
||||
5. Owner review 1, phase 4: R5 visual crop locked to the output's proportions, R6 mirroring, 90° rotations,
|
||||
1. Owner review 2, phase 5a: R8 workspace and projects with a local home (migration 0009).
|
||||
2. Owner review 2, phase 5b: R8 server home.
|
||||
3. Owner review 2, phase 5c: R8 originals, local render, clean-up, Workspace settings.
|
||||
4. Owner review 1, phase 4: R5 visual crop locked to the output's proportions, R6 mirroring, 90° rotations,
|
||||
straightening and colour filters (project settings in the workspace).
|
||||
6. Owner review 1, phase 5: R3 export panel and Render menu, R8 export options, R9 videos library.
|
||||
7. Owner review 1, phase 6: Docker, Unraid and deploy docs, BRIEF §24 amendments, full verification.
|
||||
5. Owner review 1, phase 5: R3 export panel and Render menu, R8 export options, R9 videos library.
|
||||
6. Owner review 1, phase 6: Docker, Unraid and deploy docs, BRIEF §24 amendments, full verification.
|
||||
|
||||
Phase 8 gate:
|
||||
|
||||
8. Visibility: make the `BalboSoft` organisation (and its packages) public, or publish to a public `RELEASES_REPO`, so
|
||||
7. Visibility: make the `BalboSoft` organisation (and its packages) public, or publish to a public `RELEASES_REPO`, so
|
||||
that people without an account can download releases, get update notices and pull the image.
|
||||
9. Windows runner: register an act_runner in host mode on a Windows PC (.NET SDK, Git for Windows, PowerShell 7) and
|
||||
8. Windows runner: register an act_runner in host mode on a Windows PC (.NET SDK, Git for Windows, PowerShell 7) and
|
||||
set the repository variable `WINDOWS_RUNNER` to its label. Then arm the screenshot diff: from the `ci-screenshots`
|
||||
commit of the first green `windows` job of a pull request, run `dotnet run --project src/Chronos.Tools --
|
||||
screenshots accept <dir>` and commit the PNGs to `tests/visual/baselines` (its README says how). From then on a
|
||||
visual change, or a screen without a baseline, fails the `windows` job.
|
||||
10. On Windows: install the latest pre-release's setup, upgrade over the previous version, uninstall (with and without
|
||||
9. On Windows: install the latest pre-release's setup, upgrade over the previous version, uninstall (with and without
|
||||
user data), silent mode.
|
||||
11. Unraid: install the template as a user template (README › Server image, Compose and Unraid) with the official
|
||||
10. Unraid: install the template as a user template (README › Server image, Compose and Unraid) with the official
|
||||
PostgreSQL template, check that its icon (the SVG of `branding/`) shows, reach the WebUI, and that the Dashboard
|
||||
shows the array's free space through *Array view*.
|
||||
12. Native-speaker review of the machine translations where users report wording (`i18n export` per language).
|
||||
11. Native-speaker review of the machine translations where users report wording (`i18n export` per language).
|
||||
@@ -72,8 +72,8 @@
|
||||
| 1 | R1 `:latest`, R2 array space, R4 gear and Settings at the bottom, R5 About inside Settings, R9 whole-folder import | done 2026-10-26, released as `v0.1.0-rc.3`: BRIEF §12.1, §12.4, §12.8, §12.9, §13, §14.4, §14.8, §14.9, §19.3, §19.5, §19.6, §24; 12 DECISIONS rows dated 2026-10-26 (R1 `:latest` and `release-channels`; R2 space path, mountinfo file system, fall-back warning, write volume, 507 at completion, `VolumeSpace`; R4/R5 admin menu and About group; R4 gear icon and `icons.py` generating `icons.js`; R5 desktop About page; R9 whole-folder grouping and its session key); CHANGELOG [Unreleased]; STATUS 8.3. `:latest` appears with the next pre-release: re-publishing `v0.1.0-rc.2` builds the tag's `Chronos.Tools`, which lacks `release-channels` | `1f089888` |
|
||||
| 2 | R11 log settings, R10 scheduled jobs (migration 0007) | done 2026-10-27, released as `v0.1.0-rc.4` (one adversarial review round, 35 findings fixed; strings in all 38 languages): BRIEF §5, §6.2, §7, §12.5, §12.6, §12.8, §14.1, §14.3, §14.6, §14.8, §14.9, §19.6, §24; 30 DECISIONS rows dated 2026-10-26 (R10 text recurrence form instead of cron, compare-and-set claim, system schedules seeded once, the timers they replace, catch-up, live services that are not schedules, the trash only reported, history and audit purges in clean-ups, one audit retention, scan at start, deep analysis read at run time, 6-hour upload sweep, Scheduled as a Jobs tab, Backup and Cleanup job kinds, 500 sequences per job, index backups and one backup retention, the archive.json timer, schedule API and audit, `scheduleChanged`, time zone, cache trim, desktop toasts, texts and archive reopening; R11 log defaults, rotation and pruning, the Debug/Trace fix, `CHRONOS_LOG_LEVEL` locking both levels, the log settings DTO and desktop rows, logging that never fails a job), six earlier rows marked superseded; CHANGELOG [Unreleased] with the `CHRONOS_LOG_LEVEL` and migration 0007 upgrade notes; STATUS 8.3 | `af9eeaab` |
|
||||
| 3 | R6 library on the panel, photo delete and trash (migration 0008), R3 web upload | done 2026-10-27, released as `v0.1.0-rc.5` (one adversarial review round and two fix rounds, 40 findings fixed; strings in all 38 languages; tried by hand in a browser): BRIEF §5, §7, §12.2, §12.5, §14.3, §14.4, §14.5, §14.8, §24; 24 DECISIONS rows dated 2026-10-26 (R6 photo trash layout, deletion journal and hidden pending record, restore journal and `.restoring` staging under the entry lease, restore rules and kept reasons, tombstones in sidecar and index, never-hashed photos hashed at deletion with the missing ones left without a tombstone as a known limitation, positions and follow-ups, Empty only as an explicit job with a fingerprint and never scheduled, trash API and audit, photo-delete permission and body limit, bulk limits of 1,000 a request and the verify fix, the upload tombstone checks and the explicit restore flag, sync tombstones and aliases, hidden dot files refused, Library navigation and the on-demand upload module, facets and covers, panel confirmations, CSV and grids, live refresh without job kinds, static files `no-cache` with ETag; R3 in-house SHA-256 worker, fail-closed self-test, no folder upload and `server/info` extensions, upload pacing and capture time, Cancel deletes and Close keeps); CHANGELOG [Unreleased] with the migration 0008 upgrade note and the known limitations; STATUS 8.3 | `9aa818ed` |
|
||||
| 4a | R7 Reorganize after import | done 2026-10-27, released as `v0.1.0-rc.6` (one adversarial review round and six fix rounds; strings in all 38 languages): BRIEF §5, §7, §7.1, §12.2, §12.5, §12.8, §13, §14.3, §14.5, §14.8, §24; 25 DECISIONS rows dated 2026-10-26 (R7 one naming rule `FrameNaming` for import, upload and Reorganize; what Reorganize renames and what stays whole; unique names in index order and XMP companions; the two-phase file journal; step order and checks under the leases; the fingerprint pinning file renames by digest; sequences still receiving photos; a sequence left inside a moving folder taken along; Reorganize as the `move` job with held plans; the whole-plan tally and errors; `sequenceChanged` `reorganized` and the editor reload; exports rebased with their folder; the rows of a sequence that took the old folder never follow; writers under the lease and render filing's 503; a folder another sequence holds refused by every writer; proxy lease batches; case-only and stable folders; template rules; rules held only to templates given anew; the server's plan cache; the reorganize API; panel selection and dialog; the desktop dialog and the Settings toast; render leftovers removed only where the sequence is; originals restored only where the sequence is), three earlier rows marked superseded; CHANGELOG [0.1.0-rc.6] with the template upgrade note and the known limitations; STATUS 8.3 | |
|
||||
| 4b | R7 mass conversion | todo | |
|
||||
| 4a | R7 Reorganize after import | done 2026-10-27, released as `v0.1.0-rc.6` (one adversarial review round and six fix rounds; strings in all 38 languages): BRIEF §5, §7, §7.1, §12.2, §12.5, §12.8, §13, §14.3, §14.5, §14.8, §24; 25 DECISIONS rows dated 2026-10-26 (R7 one naming rule `FrameNaming` for import, upload and Reorganize; what Reorganize renames and what stays whole; unique names in index order and XMP companions; the two-phase file journal; step order and checks under the leases; the fingerprint pinning file renames by digest; sequences still receiving photos; a sequence left inside a moving folder taken along; Reorganize as the `move` job with held plans; the whole-plan tally and errors; `sequenceChanged` `reorganized` and the editor reload; exports rebased with their folder; the rows of a sequence that took the old folder never follow; writers under the lease and render filing's 503; a folder another sequence holds refused by every writer; proxy lease batches; case-only and stable folders; template rules; rules held only to templates given anew; the server's plan cache; the reorganize API; panel selection and dialog; the desktop dialog and the Settings toast; render leftovers removed only where the sequence is; originals restored only where the sequence is), three earlier rows marked superseded; CHANGELOG [0.1.0-rc.6] with the template upgrade note and the known limitations; STATUS 8.3 | `7e4a3b48` |
|
||||
| 4b | R7 mass conversion | done 2026-11-02, released as `v0.1.0-rc.7` (one adversarial review round, 42 findings, and two fix rounds; strings in all 38 languages): BRIEF §5, §7, §8.1, §8.3, §8.7, §9, §12.2, §12.4, §12.5, §13, §14.3, §14.4, §14.5, §14.8, §14.9, §24; 26 DECISIONS rows dated 2026-10-26 (R7 conversion after import, import still byte for byte; Replace or New sequence at every run, never remembered; targets and the scene-referred archival DNG; the conversion's decoder order, managed first and no 16-bit file from an 8-bit RAW development; the TIFF reader's refusals; colour profiles carried, converted or refused; the converted files' Exif; a dry run that probes what it promises; exactly the confirmed photos, by digest and ids; the two-stage, resumable job; the purge of staging and journals; free space measured where the conversion writes; no conversion of the same sequences twice; New sequence holding the converted copies alone, saying what it lacks; the Replace swap; the replace journal decided by content; Undo by the job's own entries; replaced entries weighed against the archive on disk; every last copy named before the typed confirmation; sync aliases as equivalence classes; link by content, proxies and downloads following them; the ingest taking a replaced original as present; the plan cache shared with Reorganize; the convert API; the `convert` job kind; failure sentences by cause), four earlier rows marked superseded in part; CHANGELOG [0.1.0-rc.7] with the upgrade note and the known limitations; STATUS 8.3 | |
|
||||
| 5a | R8 workspace and projects with a local home (migration 0009) | todo | |
|
||||
| 5b | R8 server home | todo | |
|
||||
| 5c | R8 originals, local render, clean-up, Workspace settings | todo | |
|
||||
|
||||
Reference in new issue
Block a user