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

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:
Alby96andClaude Opus 5.5 authored and Alby96 committed 2026-11-03 10:41:50 +01:00
1 parent 7e4a3b481d
commit efa87f68ce
354 files changed
+24530 -843

No files matched your search

+47 -4
View File
@@ -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. |