feat: owner review 2 phase 4b: mass conversion after import (#13)
CI / Build and test (push) Failing after 3m1s
CI / PostgreSQL 16 integration (push) Skipped
CI / PostgreSQL 17 integration (push) Skipped
CI / Docker image (push) Skipped
CI / Windows tests and installer (push) Skipped
CI / YAML check (push) Successful in 10s
Release / Build, test and publish (push) Successful in 15m31s
Release / Server image (push) Successful in 1m13s
CI / Build and test (push) Failing after 3m1s
CI / PostgreSQL 16 integration (push) Skipped
CI / PostgreSQL 17 integration (push) Skipped
CI / Docker image (push) Skipped
CI / Windows tests and installer (push) Skipped
CI / YAML check (push) Successful in 10s
Release / Build, test and publish (push) Successful in 15m31s
Release / Server image (push) Successful in 1m13s
Convert photos already in the archive to JPEG, TIFF-16 or Linear DNG, from the panel's Library and the desktop's Archive and Library. Each run asks Replace (same frames, originals to the trash, recoverable) or New sequence. A dry run lists what converts, what is skipped and why, size before and after, and free space; the job converts exactly the confirmed photos, resumes, and commits all or nothing per sequence. A conversion never changes what Chronos reads from a photo. Replaced originals are erased only on the archive's own word that their conversion is gone. Desktop TIFFs that WIC showed black or as noise now go to the managed reader; the Edit picker no longer spins a core. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: Alberto Balbo <alberto.balbo.96@gmail.com>
This commit was merged in pull request #13.
This commit is contained in:
1 parent
7e4a3b481d
commit
efa87f68ce
354 files changed
+24530
-843
No files matched your search
+27
-18
@@ -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 (by the name only without colorant tags), `IsSrgbFor` (the values a DNG takes), `WithSrgbCurve` and `GrayAsRgb` (the profiles a conversion makes), 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,8 @@ 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) |
|
||||
| `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 and Reorganize: 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) |
|
||||
| `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 Chronos reads never changes, so the colour space is carried (code values), described by a profile made for the values written (`Describe`: float values as sRGB codes, a gray curve as RGB) or refused (a DNG takes sRGB's values only); pixels that are not numbers fail as damaged; 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, without overflow; a frame another host flagged undecodable asked again where other decoders (WIC) read it; 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 |
|
||||
| `Diagnostics` | `Log` (never throws: a line its sink cannot write is dropped), `FileLogSink` with `LogFileOptions` (level, daily or hourly files, numbered parts past a size, pruning by age and by the total size, never the file being written), synthetic sequences, `SecretScrubber`, `DiagnosticsArchive` (scrubbed diagnostics zip) |
|
||||
@@ -54,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), 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 one `SidecarWalk` of the archive per dry run or emptying) through their replaced tombstones, a conversion deleted only on the archive's word (a tombstone, the trash, or an `ErasureRecord` in `trash/.erased/`, written when an emptying erases a deleted sequence a replaced entry still needs), `TrashEntry.ConversionDeleted` in the dry run and its fingerprint, the erase weighed under the entry's and the sequence's leases once the sequence is settled; `BusyAsync`: what running and paused jobs hold, but the job asking, from `JobRepository.ListHoldsAsync`), `FrameTrash` (photos of a sequence into `trash/photos` with a dry run, a journal that undoes an interrupted deletion whose entry stays unlisted until its sidecar is written, tombstones (a photo never hashed is hashed as it goes; one whose original is missing goes without a file or tombstone; a frame that stays and may be a twin is hashed, its hash kept), positions parked and placed back, proxies and thumbnails moved to follow their frames; `FrameTrash.Restore`: restore re-hashes each file and says why each kept photo stayed (`KeptReason`), under a journal of its own into the sequence that another writer settles only under the entry's lease, into a new sequence through the ingest when theirs is gone, each original staged inside its own entry and the record rewritten after each photo filed; a replaced entry swaps back while its converted frames are unchanged (`SwapBackAsync`); `FrameTrash.Replace`: the files of frames swapped in place, same iLine 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
|
||||
|
||||
@@ -68,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), 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
|
||||
@@ -85,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, with `ReorganizePlanCache`: a dry run's plan, made apart from its request, kept a few minutes while what it reads from the index stays, 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) |
|
||||
| `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 |
|
||||
|
||||
@@ -116,6 +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`, `ConvertJobParameters`: the target, quality and mode, the sequences with their frames version and the digest of the photos confirmed, whose ids wait in `journal/convert-<job>.photos`, 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)
|
||||
@@ -161,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`, `.photos`) 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
|
||||
@@ -172,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 |
|
||||
|
||||
+368
-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, .photos: 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; .erased/: what Empty erased that a replaced entry needs (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,10 +462,17 @@ 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.
|
||||
- `trash/.erased/<sequence id>.json` (amended 2026-10-26, R7): the record that Empty erased a
|
||||
deleted sequence (its id, title, entry, when and by whom), written before the folder goes
|
||||
while a replaced entry of that sequence stays in the trash, and never while the sequence also
|
||||
lives (this index has it, or a folder's sidecar names it). Each Empty deletes the records no
|
||||
listed replaced entry needs. The trash never lists them.
|
||||
- In a sequence's `.chronos/`, `remove.pending.json` is written before a photo deletion's
|
||||
first move and `restore.pending.json` before a restore's; until the sidecar is written the
|
||||
entry's record is `<name>.json.pending`, which the trash never lists, restores or empties.
|
||||
@@ -471,6 +482,22 @@ 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 (once
|
||||
per dry run or Empty, again only for a sequence no longer where the walk found it), followed
|
||||
through its replaced tombstones. A conversion counts as deleted only on the archive's own
|
||||
word: a deleted tombstone ending its chain in the sequence's sidecar, the sequence in the
|
||||
trash, or the trash's record of erasing the sequence (`.erased/`), which outweighs a stale
|
||||
row of this index but not a live sidecar. Anything else keeps the entry: a sidecar that holds
|
||||
none of the conversion and no tombstone of it (one rebuilt by adoption), a sequence found
|
||||
nowhere with no erasure record (the walk may have skipped its folder), a frame never hashed.
|
||||
|
||||
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 +543,60 @@ 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.
|
||||
- The photos a confirmation lists are written whole, before its job is queued, into
|
||||
`journal/convert-<job>.photos` (one line per sequence, each frame id in plan order); the job
|
||||
record keeps each sequence's digest alone, so it grows with the sequences, not the photos.
|
||||
Without that file the job holds each sequence to its whole plan made again (the same digest).
|
||||
- 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. Before each photo the free space
|
||||
must hold it and every photo started whose converted file has not landed yet (a file lands
|
||||
whole, by a rename, before it is verified). 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), and the journal names that copy
|
||||
as soon as its photos are filed. A retry or resume finishes the copy it named (or finds by its
|
||||
session key) once that copy holds every pinned photo, whatever changed in the source since; it
|
||||
never remakes a copy deleted since (the sequence is then changed: plan again). A source that
|
||||
another conversion copied in the same format after this one was confirmed gets no copy
|
||||
(outcome superseded, in the job's log) once that conversion is done; while it is not, the
|
||||
sequence is left for the retry.
|
||||
- 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 +649,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 (never WIC for a compression it does not decode, a floating-point predictor or 32-bit integer samples, which it reads as black or noise; amended 2026-10-26, R7) | 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 +697,19 @@ 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, the profiles a conversion makes for the values it writes (a profile's
|
||||
colorants with the sRGB curve, a gray curve as RGB), 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 +738,70 @@ 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 photo another host flagged unreadable is asked
|
||||
again where the conversion has other decoders (WIC on a PC) and planned when they decode it at
|
||||
full resolution; a corrupt one stays out everywhere. WIC is never used for a TIFF whose
|
||||
compression is not 1–5, 7, 8, 32773 or 32946, whose predictor is other than none or the
|
||||
horizontal one on integer samples, or whose integer samples exceed 16 bits (WIC gives black or
|
||||
noise for them without an error), in conversions and in every other desktop decode: the
|
||||
managed reader takes it, or it is unavailable. A conversion's WIC probe reads the file's headers (the decoder, the
|
||||
first frame's upright size, the pixel format), so the size bounds apply to what only WIC
|
||||
reads; a file it cannot open is missing or held, never unreadable.
|
||||
- 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: what Chronos reads from a photo never changes. Its decoders read no profile: they take
|
||||
code values through the sRGB curve and a float TIFF's values as they are. A converted file
|
||||
holds the values they read from the original, as they read them back, within what the target
|
||||
holds (a JPEG or TIFF-16 holds 0..1 and clips beyond; a DNG up to 4 stops above white), and
|
||||
says truthfully what those values are:
|
||||
- A JPEG or TIFF-16 keeps the codes of an RGB profile's code values and carries that profile.
|
||||
Float values are written as sRGB codes with a profile made for them: the original's
|
||||
colorants and media white with the sRGB curve ("<description> (sRGB curve)"). A lookup-table
|
||||
profile named sRGB is carried; other float values in a lookup-table profile are refused. A
|
||||
gray profile's codes are kept, its curve carried as an RGB profile with sRGB's colorants
|
||||
("<description> (RGB)"); linear gray needs no profile.
|
||||
- A linear DNG, whose matrices Chronos develops it with too, takes only values that are sRGB's
|
||||
as read: no profile, an sRGB profile, float values in sRGB's primaries whatever the curve,
|
||||
linear gray, gray codes on the sRGB curve. Any other profile (Adobe RGB, Display P3,
|
||||
ProPhoto, a gamma-1.0 profile's code values) is refused as `color_profile`; TIFF-16 and JPEG
|
||||
convert those photos with their profile.
|
||||
- A matrix/TRC profile is sRGB by its numbers (its matrix within 2e-3 of sRGB's, its curves
|
||||
within 2e-3 of the sRGB curve), by its name only when it has no colorant tags at all; one
|
||||
whose colorants convert nothing, or that has no curves, is never sRGB.
|
||||
- Exif Adobe RGB (uncalibrated with Interop R03) and a HEIF nclx box with P3 primaries get the
|
||||
in-house profiles. Refused for every target: CMYK, Lab and other non-RGB profiles, Exif
|
||||
uncalibrated without R03, other nclx primaries or an HDR transfer, a profile that does not
|
||||
parse. A photo that records no colour space is sRGB.
|
||||
- Damaged values: a photo whose decoded pixels hold NaN or infinite values fails as damaged
|
||||
data, and nothing is written.
|
||||
- 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). Sizes are weighed without overflow, so a damaged header's
|
||||
absurd size is too large, never a wrapped number.
|
||||
- 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 +821,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 +1018,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 +1093,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 +1118,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 +1137,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 +1168,19 @@ 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 the archive itself shows deleted since (§7; *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 and what settles it, an entry changed since the plan, one whose
|
||||
sequence is busy, one whose conversion no longer matches, one with a photo never verified
|
||||
(verify the sequence), one where a sidecar that may hold the sequence is missing or
|
||||
unreadable (scan the archive), one whose sequence the index lists but the archive no longer
|
||||
holds (rebuild the index), and one whose conversion's fate the archive does not show (restore
|
||||
it to keep its photos; a frame missing or corrupt, which no verify hashes, counts here).
|
||||
|
||||
*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 +1225,59 @@ 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
|
||||
cannot keep, for a linear DNG any but sRGB (§8.7); larger than the format holds or Chronos
|
||||
reads back; 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 (counting every photo still being written), 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. A retry
|
||||
finishes the copy the job made and never makes a second; a source another conversion copied
|
||||
in the same format since this one was confirmed gets no copy (the job log says so), and waits
|
||||
for the retry while that conversion has not finished.
|
||||
- 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 +1396,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 +1484,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 +1527,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 +1571,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 +1593,53 @@ 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 digest (its photos are kept beside the job's journal, §7).
|
||||
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 +1687,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 +1740,29 @@ 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 even when the job is stopped meanwhile; 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 +2001,35 @@ 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 the archive shows 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 +2068,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 +2535,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), what Chronos reads from a photo never changed (profiles carried, a linear DNG of sRGB values only), Exif carried, every file verified by the server's decoders; Replace swaps the files of the frames in place under a crash-safe journal, the originals going into a replaced trash entry that Undo or Restore swaps back and that Empty erases only while the archive on disk shows each conversion intact, or deleted on its own word (a tombstone, the trash, an erasure record); import still copies byte for byte and the card keeps a converted photo's copy; sync and the ingest count every encoding of a photo as one; `POST /api/v1/archive/convert` with the plan cache it shares with Reorganize, `sequenceChanged` `converted` and `created`, the audit `archive_converted`. |
|
||||
|
||||
## Appendix A — `CLAUDE.md` content (create verbatim in Phase 0, keep updated)
|
||||
|
||||
|
||||
@@ -5,6 +5,116 @@ 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. A PC asks its own decoders again about a photo the server found unreadable (a CMYK
|
||||
TIFF), so it converts what it reads. 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 (counting every photo still being written) and stops before the volume fills. A second
|
||||
conversion of the same sequences is refused while the first waits or runs. A retried New sequence conversion
|
||||
finishes the copy it already made and never makes a second one; a source another conversion copied in the same
|
||||
format since this one was confirmed gets no copy (the job's log says so), and while that other conversion has not
|
||||
finished, the source waits for its retry.
|
||||
- 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 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).
|
||||
- A conversion never changes what Chronos shows of a photo: the converted file decodes to the values the original
|
||||
decoded to, within what the format holds. A JPEG or TIFF-16 keeps the photo's values and carries its colour profile; a float TIFF's values get a
|
||||
profile made for them, with the original's primaries, and a gray profile's tones are kept. A linear DNG takes only
|
||||
photos whose values are sRGB as Chronos reads them (RAWs, photos without a profile, sRGB): photos in Adobe RGB
|
||||
(camera JPEGs tagged so included), Display P3 (HEIC), ProPhoto or a gamma-1.0 profile stay as they are, with "a
|
||||
colour profile the format cannot keep"; TIFF-16 and JPEG convert them with their profile. A file whose pixels hold
|
||||
values that are not numbers fails as damaged and nothing is written.
|
||||
- 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. A conversion counts
|
||||
as deleted only when the archive says so (a deletion recorded in its sequence's sidecar, the sequence in the trash,
|
||||
or the trash's record of erasing that sequence); such originals are named first in its confirmation ("conversion
|
||||
deleted"), since they may be the last copy of their photos. Whatever the archive cannot tell keeps the entry.
|
||||
- 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); a
|
||||
damaged file that still decodes (a truncated TIFF strip, a corrupt JPEG scan) converts as the partial picture its
|
||||
decoder gives; a read error while the dry run reads the headers of a TIFF, a DNG or a TIFF-based RAW lists that
|
||||
photo as needing a PC, preview-only or unreadable rather than held open (it stays as it is); JPEG and TIFF-16 clip a
|
||||
float TIFF's values above white and below black; 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, never verified or not 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 and what settles it: changed after the plan, its
|
||||
sequence busy, a conversion that no longer matches, a photo never verified (verify the sequence), a sidecar missing
|
||||
or unreadable (scan the archive), an index row the archive does not bear out (rebuild the index), or a conversion
|
||||
whose fate the archive does not show (restore the entry to keep its photos).
|
||||
- Desktop: a confirmation with a long list scrolls it, so its buttons stay on screen; Tab reaches the list, which
|
||||
then scrolls with the arrow, page and Home/End keys.
|
||||
- **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.
|
||||
- On a PC, TIFFs that WIC decodes wrongly without an error (a compression it does not know, such as ZSTD or JPEG
|
||||
2000, which came out black; Photoshop's 32-bit files with a floating-point predictor and 32-bit integer samples,
|
||||
which came out as noise) are left to Chronos's own TIFF reader, or are unreadable, in renders, thumbnails and
|
||||
analyses as in conversions.
|
||||
- Edit: the picker no longer spins a processor core and stops responding when the list is loading a page as it
|
||||
looks for the sequence edited last.
|
||||
|
||||
## [0.1.0-rc.6] — 2026-10-27
|
||||
|
||||
### Added
|
||||
|
||||
+47
-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,50 @@ 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 | (Partly superseded by the 2026-11-03 conversion colour and sRGB by name rows: float values are written as sRGB codes with a profile made for them, a linear DNG takes only values that are sRGB's as read and refuses other profiles, a gray profile's codes are kept with its curve as an RGB profile, and a name decides sRGB only for a profile without colorant tags.) 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 | (Partly superseded by the 2026-11-03 flagged frames and size bounds rows: a frame another host flagged undecodable is asked again where the conversion has other decoders, and sizes are weighed without overflow.) 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 | (Partly superseded by the 2026-11-03 confirmed photos file and New sequence retries rows: the frame ids live in `journal/convert-<job>.photos`, not in the parameters, and a retry finishes a copy already filed instead of reporting its sequence changed.) 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 | (Partly superseded by the 2026-11-03 stage A space row: before each photo the job counts that photo and every photo still being written.) 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 | (Partly superseded by the 2026-11-03 deleted on the archive's word, erasure record, kept reasons and sidecar walk rows: a conversion is deleted only on a tombstone, the trash or an erasure record, never inferred from absence; more kept reasons, each with its advice; one walk per dry run or emptying.) 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. |
|
||||
| 2026-11-03 | Conversion colour: a conversion never changes what Chronos reads from a photo. Chronos's decoders (managed and WIC) never read a profile: code values go through the sRGB curve, float and LinearRaw samples are taken as they are. Every converted file holds the values they read from the original, as they read them back, within what the target holds (JPEG and TIFF-16 0..1 at 8 or 16 bits, clipped beyond; a DNG 16-bit linear values up to 4 stops above white), and says truthfully what they are (`FrameConverter.Treatment`: `None`, `Carry`, `Describe`, `Refuse`). JPEG and TIFF-16: an RGB profile's code values keep their codes and carry the profile; float values are written as sRGB codes with a profile made for them, the source's colorants and media white (to the bit) with the sRGB curve (`IccProfile.WithSrgbCurve`, version 2.1, "<description> (sRGB curve)"); a lookup-table profile named sRGB is carried, other float values in a lookup-table profile are refused; a gray profile's codes are kept and carry the gray curve on three channels with sRGB's D50 colorants (`IccProfile.GrayAsRgb`, "<description> (RGB)"); linear gray needs no profile. Synthesized descriptions are ASCII, at most 200 characters. Linear DNG holds the values as decoded and takes only values that are sRGB's as read (`IccProfile.IsSrgbFor`): untagged, an sRGB profile, float values in sRGB's primaries whatever the curve, linear gray, gray codes on the sRGB curve. Every other profile (Adobe RGB, camera JPEGs tagged Exif R03 included, Display P3 (HEIC), ProPhoto, a gamma-1.0 profile's code values) is refused as `color_profile`; TIFF-16 and JPEG convert those photos with their profile. RAWs, untagged and sRGB photos are unaffected. (Owner review 2, R7, fix round 3.) | Code float values with the profile's own curves, convert a DNG's values through the profile's matrix and a gray profile to sRGB (round 2) | Chronos reads no profile, so round 2 changed what a Replace showed: an Adobe RGB, ProPhoto or gamma-1.0 float TIFF rendered up to 2.7 EV darker or with lifted shadows, a gray photo changed tones, and a non-sRGB photo in a DNG showed more saturated (a sequence mixing converted and unconverted frames would flicker in colour). Renders, thumbnails, analyses and deflicker must see the same pixels after a Replace; a DNG's matrices are its colour, so values in another space can be neither converted nor left mislabelled. |
|
||||
| 2026-11-03 | sRGB by name: `IccProfile.IsSrgb` takes a profile's name into account only when it has no rXYZ, gXYZ or bXYZ tag at all. A profile whose colorants were dropped as converting nothing, or that has no curves, is never sRGB: it is carried with code values and refused where its colorants are needed (float values into JPEG or TIFF, anything into a DNG). A lookup-table profile named sRGB is still sRGB. (Owner review 2, R7, fix round 3.) | Trust any profile named sRGB | A degenerate profile named "sRGB-elle-V4-g10" holds gamma-1.0 values, not sRGB's. |
|
||||
| 2026-11-03 | Damaged values: decoded pixels holding NaN or infinite values (`FrameConverter.AllFinite`) fail the photo as `ConversionFailure.Damaged` (`Archive.Convert.Failed.Damaged`), in every target, tagged or untagged, and nothing is written; like any failed photo, its sequence stays as it was (all or nothing). (Owner review 2, R7, fix round 3.) | Write them as black | A damaged float file turned black, and in a DNG spent the headroom; with Replace it would have taken the original's place. |
|
||||
| 2026-11-03 | Size bounds: `ConvertPlanner.TooLarge` compares W·H with `MaxSamples`/3 without multiplying past a long; `WorstBytes` and `EstimateBytes` saturate at `long.MaxValue`. So damaged header sizes (sides up to int.MaxValue) are `too_large` for every target. The too_large sentences say "larger than this format holds or Chronos reads back" (en, it). (Owner review 2, R7, fix round 3.) | Multiply as before | A product that wrapped around let an absurd size pass as a small one. |
|
||||
| 2026-11-03 | Flagged frames: in `ConvertPlanner.Skip` a frame flagged `Corrupt` is undecodable everywhere, and one flagged `Undecodable` only where the conversion's decoders have no native provider besides the managed one for its format. Where they do (WIC on a PC), it is planned when its header probe is native and a 64-px decode by those decoders gives native pixels, else it stays undecodable; a read error during that decode is `Inaccessible`. The tier recorded is unchanged: the server still flags CMYK and CIELab TIFFs, which keeps them out of its renders and out of a PC's renders too; only the conversion asks again. (Owner review 2, R7, fix round 3.) | Trust another host's flag | The server flags a CMYK TIFF its reader refuses; a PC reads it through WIC and must be able to convert it. |
|
||||
| 2026-11-03 | WIC TIFF refusal: `WicDecoderProvider` reads a TIFF's first IFD (WIC's frame 0) and refuses it when its compression is not 1, 2, 3, 4, 5, 7, 8, 32773 or 32946, its predictor is other than 1, or 2 on integer samples, or its integer samples exceed 16 bits. `Decode` then returns null in every desktop decode (renders, thumbnails, analyses, conversions), so the managed reader decodes it or it is unavailable. Checked on Windows 11: WIC decodes the compressions listed; others (ZSTD, JPEG 2000, LERC, LZMA, WebP, unknown codes) come out as zeros without an error, and 6, 34661, 34676 and 34677 raise one; it undoes only predictor 2 on integer samples (Photoshop's floating-point predictor 3 gives NaN or noise) and reads 32-bit integer samples as floats. (Owner review 2, R7, fix round 3.) | Trust what WIC returns | WIC returns a picture without an error for what it does not decode: the desktop showed black or noise, and a Replace would have converted it so. |
|
||||
| 2026-11-03 | Header probes: `IImageDecoderProvider.WithHeaderProbes()` (the provider itself by default; the managed provider's `ReadsHeaders` twin; WIC's a twin on the same codec snapshot) gives a conversion's decoders probes that open the file. WIC's reads the decoder WIC picks (the Raw Image Extension for a RAW), applies the TIFF refusal, reads the first frame's upright size and checks that its pixel format converts; anything else WIC answers is unavailable, with a reason. An error opening the file propagates: not found is missing, a sharing violation or denied access is inaccessible. Imports and analyses keep the probes that open nothing. (Owner review 2, R7, fix round 3.) | WIC's probe by codec alone | A file only WIC reads, whose size the index did not know, was found too large only when it converted; a held file must not be planned as unreadable. |
|
||||
| 2026-11-03 | Stage A space: before each photo the job reserves that photo and every photo handed to the work whose converted file has not landed yet (converting or waiting for a slot, up to twice the parallelism), scaled by how far this run's staged files came out above their estimates, with the 15 % margin and the 512 MiB reserve (`MassConverter.SpaceWatch`: `Start`, `Writing`, `Ended`, the free space injected). A photo stops counting once its target file appears, or replaces the file there when it started (by size and write time). (Owner review 2, R7, fix round 3.) | That photo and those after it that may convert at once (round 2); each photo until its work ends | Near the end of a sequence round 2 counted one photo while up to twice the parallelism were still converting, so a volume filling meanwhile could go into the reserve. A file lands whole, by a rename, before it is verified: counting it until its verify ends would count it twice. |
|
||||
| 2026-11-03 | Confirmed photos file: the confirmed frame ids live in `.chronos/journal/convert-<job>.photos` (`ConfirmedPhotos`: JSON lines, one per sequence, the ids in plan order, 16 bytes each in base64), written whole by `MassConverter.QueueAsync` before the job is queued, under an id chosen first (`ArchiveJobRequest.Id`, `JobEngine.EnqueueAsync(Guid id, …)`), and deleted if the enqueue throws. The job row keeps each sequence's id, frames version and digest (`ConvertSequence`), so it grows with the sequences, not the photos. Without the file (not writable, or a job a round 2 build queued with `photos` in its parameters, now ignored) the job holds each sequence to its whole plan made again. The file goes with the journal (`ConvertJournal.Files`) and maintenance treats it as one of its files. What reads job rows: the busy check (`SequenceTrash.BusyAsync`) only ids, kinds, targets and a Verify's parameters (`JobRepository.ListHoldsAsync`), the asking job excluded in SQL; a conversion's re-plan only its own creation time (`GetCreatedAsync`); the server's job list, the admin dashboard and the engine's claim and review peeks rows without parameters (`ListBriefAsync`, `ListQueuedBriefAsync`). The desktop Jobs page still reads whole rows. (Owner review 2, R7, fix round 3.) | Keep the ids in the job's parameters (round 2) | About 21 MB of ids for a million photos was read by every dry run's busy check, by each sequence turn of the conversion and by the job lists; the reads grew with the square of a job's size. |
|
||||
| 2026-11-03 | New sequence retries: the journal names the copy as soon as its photos are filed (`ConvertJournal.Made`; a later note keeps it). A retry or resume that finds the job's own copy (by the journal, else by its session key) holding the converted file of every pinned photo finishes it (`FinishCopyAsync`: the source's tags, rating, notes and project, follow-ups, outcome `Created`), whatever changed in the source since. A copy the job made and that was deleted since is not remade (`Changed`: plan again). The retry's opening space check does not count photos already filed into its copy. (Owner review 2, R7, fix round 3.) | Report the sequence changed and plan again (round 2) | The copy was left orphaned and the new plan made a second one. |
|
||||
| 2026-11-03 | Superseded copies: new outcome `ConvertOutcome.Superseded`. A New sequence job makes no copy of a source when another conversion job (session key `convert:<other>:<source>`) made a copy holding frames of this job's format after this job was confirmed (the copy's sidecar `Created` against the job's creation time, `ConvertRequester.Confirmed`) and that job is `Done`; the log says so (`Archive.Log.ConvertSuperseded`), and the job ends Done if the rest converted. While the other job is not done (it failed while filing its copy, or still runs), the sequence is `Blocked` with `Archive.Convert.CopyUnfinished`: no second copy, and not done with. A conversion confirmed after a copy already existed makes its own (the user asked again); a copy in another format does not count. (Owner review 2, R7, fix round 3.) | Copy again; let any later copy supersede, whatever its job's state | Job A failed, job B copied the same source, and retrying A made a duplicate; a copy whose job has not finished may be partial and cannot stand for this one. |
|
||||
| 2026-11-03 | Deleted on the archive's word: an emptying calls a replaced entry's conversion deleted only on positive evidence: a `Deleted` tombstone ending its chain in the sequence's sidecar, the sequence in the trash, or the trash's erasure record of the sequence. `SequenceHoldings.Classify` no longer infers it from "every frame hashed, none holds it", and a sequence with no sidecar anywhere and no row in this index is no longer gone. A sidecar that holds none of the conversion and no tombstone of it (one rebuilt by adoption keeps only this index's ids and tombstones), or a sequence found nowhere without an erasure record (the walk may have skipped its folder: photos without a sidecar, or a folder it cannot enter), keeps the entry, and a kept entry is never flagged `ConversionDeleted`. The erasure record outweighs a stale row of this index; a live sidecar found anywhere outweighs the record. (Owner review 2, R7, fix round 3.) | Infer deletion from absence (round 2) | After a routine verify of a rebuilt sidecar, a damaged conversion still in its folder counted as deleted: the dry run called the originals the last copy and the emptying erased them. |
|
||||
| 2026-11-03 | Erasure record: `.chronos/trash/.erased/<sequence id N>.json` (`ErasureRecord`: sequence id, title, entry, erased at, erased by). An emptying writes it before a deleted sequence's folder goes, only while a replaced entry of that sequence is listed, and never while the sequence also lives (this index has a row of it in this archive, or the walk finds a folder whose sidecar names it: a folder copied back and adopted, a second deletion of the same id). Each emptying ends by deleting the records no listed replaced entry needs. The trash listings never see the folder. A sequence entry erased by an earlier build leaves no record, so its replaced originals stay until restored (phase 4b is unreleased). (Owner review 2, R7, fix round 3.) | Nothing on disk; take a missing sequence as gone | Once the folder is gone, only the archive can tell a later emptying, or another host, that the conversions went with the sequence; a record beside a live copy would outlive what it says and let a walk that misses that folder erase originals whose conversion is still there. |
|
||||
| 2026-11-03 | Kept reasons: `TrashKeptReason` gains `Unhashed` (`Archive.Log.TrashKeptUnhashed`: a frame that may hold the conversion was never verified; verify the sequence), `Unreadable` (`TrashKeptUnreadable`: a sidecar of a folder that may hold the sequence is missing or unreadable; scan the archive) and `StaleIndex` (`TrashKeptStaleIndex`: the index lists a sequence the archive no longer holds and nothing records erasing it; rebuild the index); `Unknown` now says "restore it to keep them". A frame flagged missing or corrupt and never hashed counts as `Unknown`, not `Unhashed`: no verify hashes it (a verify does not hash a file whose size differs from its record). A rebuild drops only the row: without an erasure record the entry then shows `Unknown`, and its restore brings the originals back as a new sequence. (Owner review 2, R7, fix round 3.) | One line for a conversion that cannot be located (round 2) | Each kept entry must name the step that settles it, never one that cannot. |
|
||||
| 2026-11-03 | Sidecar walk: a dry run or an emptying walks the archive's sidecars at most once (`SidecarWalk`: sequence id to folders, the first unreadable sidecar kept). An emptying shares one walk between its plan and every erase, so nothing walks the archive under a lease, and walks again once per lookup only when a folder it found no longer holds the sequence; still moving after that, the entry is kept as Busy. A stale walk can only keep an entry, never erase one. (Owner review 2, R7, fix round 3.) | A survey per entry (round 2) | Each erase walked the whole archive again while holding the entry's and the sequence's leases. |
|
||||
| 2026-11-03 | Download follow-ups: `SyncTransfers.QueuePassesAsync` queues every pass a download needs, a frame swap's included, with `CancellationToken.None` through the new `JobContext.EnqueueFollowUpAsync(…, CancellationToken)`, as `FrameTrash.RestoreAsync` does. (Owner review 2, R7, fix round 3.) | The job's own token | A Stop right after a swap dropped the passes it cleared, leaving frames without thumbnails, proxies or analyses. |
|
||||
| 2026-11-03 | Confirmation detail keyboard: the desktop confirmation's detail (`DetailScroll`) is focusable and a Tab stop, through a style trigger, only while its vertical scroll bar shows (a detail longer than its 288 px), with the focus ring, the detail's tooltip and accessible name; the arrow, page and Home/End keys scroll it. (Owner review 2, R7, fix round 3.) | Always a Tab stop; the mouse only | A long list of entries that may hold the last copy of their photos must be readable from the keyboard; a detail that fits needs no stop. |
|
||||
+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