c5ed31bcedbc37c3e117dfe8b5c8665eca66d880
61
Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
|
|
c5ed31bced |
Merge branch 'review2-p5a-fix3-desktop' into review2-p5a-int3
Conflict in WorkspaceFallbackTests: keeps desktop's new newer-copy test and drops ACancelledFirstCopyLeavesNoHalfMedia, which the sync branch removed along with WorkspaceHost.RemovePartialMediaAsync (the cancelled first copy's clean-up now runs in the copy job, tested in Data). ReplayAsync auto-merged with both intents: desktop's working-state conflicts and silent paths, and sync's skip of no-change versions, Settles journal flag and PruneReplaced. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
c96c8947e0 | Merge branch 'review2-p5a-fix3-sync' into review2-p5a-int3 | ||
|
|
5eeb64b680 |
fix(workspace): finish or keep every choice, copy and sync a cut or a deleted project leaves
- A take of the library's values cut past its commit point settles its conflict (replay journal marks Settles); a later stale choice finds nothing to settle, and one cut before it keeps the conflict so the next choice is applied. - A local version that changes nothing once replayed on the head is not sent nor written as a Merge; its file stays in versions/.replaced. - Save both journals its intent (name, base, time) before the home is asked, so a cut after the copy was made reuses that copy on retry. - A project deleted at the home reads as Gone from pull, push, resolve and save both, logged once, without retry loops; versions and working state stay. - Save both keeps the restore recorded in sync.json. - The copy job writes a photo's new bytes under a name of its own while the editor's media still name the old file, switching at the commit; a cancelled first copy removes its own half media under the lease (VM hook removed). - Status reads the version files once, re-reads the home's frames only when its stamp moved, reports damage only when confirmed under the lease, and waits once for a busy lease before calling the media outdated. - versions/.replaced is pruned after a sync that ended well (30 days, newest 20 kept, never a file a journal names). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
bc87a57830 |
fix(projects): one atomic catch-up merge, Main settled from the records, lost records rebuilt
The catch-up merge of a push whose mirror a crash cut short with settings written meanwhile was two appends (External, then Merge), resumed by a purely structural test that also fired on ordinary histories (two outside edits in a row, a second index with an older mirror) and reverted the latest edit. It is now one Merge version on the head in which the settings written meanwhile (the settings in force, which older clients wrote) win where both changed; the head's values stay in its version. A merge that adds nothing to the head makes no version, so a cut before its mirror is finished next time by the same index or a rebuilt one without any marker. The structural resume is gone. An index meeting Main with a lagging record merges project.json the same way, so a newer outside edit is no longer reverted by an older push. Versions the catch-up records as mirrored are named in Main's record too when project.json holds them, so records no longer lag behind externals. Duplicate Main claimants (an index that met the sequence before Main's record arrived) are settled from the records: the oldest claimant with a version is Main in every index, the others are ordinary projects, and their records say so when the archive takes writes. A live project folder whose record is missing while the index holds the project gets its record (and missing version files) written again from the index instead of being held back forever. A record behind the index no longer gives the index its old name. MirrorAsync reads the version leniently and skips a newer one, as the other branches do. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
e8ea858021 |
fix: phase 5a fix round 3, desktop: newer copies, readable discard, working-state conflicts, edits kept aside
Owner review 2, R8. Round 2's checkers left five desktop problems: - A workspace copy whose project.chronos a newer Chronos wrote (a format this one does not know) was listed as damaged and offered for Discard. It is now listed as "Newer Chronos" with its own tooltip, named from what of its file still reads. It never opens, is never checked out over, and Remove local copy refuses it with a sentence that says why. - Discard of any copy moved only the files Chronos knows. It now moves every file and folder of the copy aside (only the media are deleted) and removes the folder only when nothing else came into it. - Discarding a damaged copy asked to type its folder's GUID. It now asks for the name the copy is still known by (its file, else the library's index; the project's name, else the sequence's title), else for the number of its files. The heading never shows the id. - A conflict at a path where the working state had gone back to the base value listed the local version's value. The conflict now lists the working state's value in every case. Where the working state already holds the library's value there is nothing to ask: that path takes the library's value in the replayed versions too, so they agree. - EditorSession.ReloadAsync, ResolveConflict and TakeOverAsync threw NewerSettingsException on every reload when an edit was not stored yet and the stored project became a newer Chronos's. The edit is now kept in versions/.replaced (outside the chain, never sent), a toast says so, the pending save is dropped and the newer settings are shown read-only. When the edit cannot be kept aside, the editor stays as it is and nothing is dropped. The SequenceViewModel wiring now has a view-model test: the copy's facts in Open in workspace, the refused-folder toast and its Choose folder action, and the picker for a newer copy and a damaged one. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
488b588ad9 |
fix: integrate phase 5a fix round 2
Taking the server's values no longer saves the working state as a version first (the desktop fix), so a take refused by a home that holds no versions after the base leaves the local versions as they were. The recovery test that relied on that pre-commit now saves the unsaved stack change itself before pushing it. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
47c660735f |
Merge branch 'review2-p5a-fix2-desktop' into review2-p5a-int2
# Conflicts: # i18n/en/Editor.resx # i18n/en/Tooltips.resx # i18n/it/Tooltips.it.resx # src/Chronos.Data/Workspaces/WorkspaceSync.cs # tests/Chronos.Data.Tests/Workspaces/WorkspaceRecoveryTests.cs |
||
|
|
775deda0f4 |
Merge branch 'review2-p5a-fix2-workspace' into review2-p5a-int2
# Conflicts: # src/Chronos.Data/Workspaces/WorkspaceSync.cs |
||
|
|
fd35e83dfc | Merge branch 'review2-p5a-fix2-merge' into review2-p5a-int2 | ||
|
|
64fc5521c0 |
fix(workspace): settle conflicts in one answer and give refused folders a way on
Phase 5a fix round 2 of owner review 2 (desktop):
- Take library's no longer commits the working state first, so a take that
leaves only the library's values sends no empty version; the working state
it replaces is kept aside in versions/.replaced, outside the chain.
- Conflicts list this side's value as the working state holds it, so one
answer settles them instead of asking again for the newer value.
- A conflict of format (library saved by a newer Chronos) offers only Save
both and Later, says why in its tooltip and shows no raw format numbers.
- Conflict lines count the photos a setting differs on ("Excluded frames
(3)") instead of dropping the duplicates.
- A read-only library is named as such, not as offline; checkouts from it
stay editable and their versions wait in the workspace.
- A workspace folder refused inside a library offers Choose folder, and
Settings > Workspace gets Change...: a plan (projects left, projects found)
is confirmed before the folder changes; nothing is moved.
- Open in workspace shows the copy's size and the drive's free space, and
warns when the copy would not fit with its 0.5 GB reserve.
- A cancelled first copy removes the half media it wrote.
- A copy whose project.chronos cannot be read is listed as damaged instead of
hidden, and goes only through Remove local copy > Discard, after a plan.
- Pruning keeps a version whose archive file is damaged (test added).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
|
||
|
|
e23cba3ee1 |
fix(workspace): phase 5a fix round 2, workspace sync and copy
A Save both, a recorded conflict and a damaged version file could each leave a local version out of the chain or a copy half-made at the home. This round makes every one of these end with nothing lost and nothing half done. - Save both retry: a journaled copy somebody else sent a version to (or one deleted since) is left as it is, and a new copy takes every local version. A divergence met at the copy while sending also makes a new copy, once. - Keep mine, Take server, or a pull that settles a conflict after a Save both was cut short first send the rest of the journaled versions to that copy, if it is still this workspace's. The journal is cleared at the commit point. - A conflict of format met past local versions the home already stored (their answer lost) now moves the base onto them, like any other conflict. The conflict, the base and the chain then name one version. A save-both journal follows the base when it moves. - A conflict recorded before stays while the home holds no version after the base. A base that has reached the conflict's head clears it. - Take server no longer replays or sends the version it saves first when, replayed, that version holds only the server's values. It stays in versions/.replaced for the undo. The test checks the exact history again. - Version files after the base that cannot be read, or that do not follow from it, are listed (WorkspaceProject.UnreadableVersions). The new state WorkspaceState.Damaged shows them. Commit, push, pull and resolve refuse to go past them. A damaged file whose version the home holds takes the home's copy at the next sync, and the damaged file is kept aside. Remove local copy counts these files as unsent. - PushOutcome.TooLarge raises its own WorkspaceSyncException message. The desktop says Errors.Workspace.VersionTooLarge for it and for ProjectVersionTooLargeException when a local commit is too large. - The editor maps LeaseUnavailableException from opening a busy project to Errors.Workspace.Busy. - The copy job no longer deletes, during the pass, a proxy that the editor's current media name. RemoveStale removes it after the commit. A resumed run does not keep such a file as a frame whose photo changed. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
a368dc8bf0 |
fix(projects): phase 5a fix round 2 of the projects engine
The sidecars stay the truth of a sequence's projects in the cases round 1's checkers found still open, and no version or setting is lost on the way: - An index-only Main meeting a Main another index made is written back as another project, and Main passes to theirs in one transaction through a free temporary name, so ux_projects_name and ux_projects_main never fail (the SqliteException used to escape ListAsync and leave the index and the sidecars disagreeing). A refusal is logged; the next reconcile settles it. - The reconcile takes Main from the records, in step with the index, when another index passed it on: exactly one Main per sequence, names from the records where free. - A project folder with versions and no record, of a project no index row names (a creation cut before its record), no longer holds the sequence back forever: it is left as it is and indexed once its record arrives. - A record behind the index (a projects folder put back from an older backup) is made whole from the index: its missing versions and the record are written again, at every catch-up and before any append, rename or delete. Only a record ahead of the index or naming another version is refused, with a message that says so. - An index meeting Main walks the chain down to the version the record names as mirrored (a bound, since that record write may lag project.json), so a lagging record never makes an External that reverts a newer push. When the record names a mirrored ancestor, settings written since merge with the unmirrored versions, as for an index that knows its mirror. - The catch-up merge's External + Merge pair is resumable: an External head whose parent is a push no mirror wrote is finished into its Merge version next time, by this index or one rebuilt from the sidecars. - A project deleted at the home has no head there, so a workspace copy of it reads Gone, never In sync; Remove local copy without discard says the project was deleted in the library. - DatabaseExceptions are contained per sequence in the archive scan's project reconcile and in ProjectService reads. Tests: SQLite (PostgreSQL-ready) for each scenario, including a cut between the two catch-up versions, a 40,000-exclusion version through save, push and rebuild, and the App's Remove local copy of a project deleted at home. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
43b092bd5d |
fix(workspace): newer-format editor stays usable; media learn the home's photo names
A pull onto a newer Chronos's settings made the editor throw: ProjectHistory.Replace rebased every undo and redo snapshot through ProjectMerge, which refuses to merge a newer format when both sides changed, so any non-empty undo stack broke the reload after a sync that had succeeded. Replace now drops the steps instead when either side (or a step) is of a newer format: the project is shown read-only and undo never brings back values from before the newer settings. The media learnt the home's hashes and conversion aliases only inside a replay, so a status or Save version before that compared a SHA-named base with photo-named media and read a false Modified or saved a version that only re-keyed photos. Now: - ProjectContent.SameChoices also compares the texts as placed on the frames, hashed or not (Bound), so status and commit without a home agree with the base; - a status asked of the home teaches the media its names (written under the lease, or when the lease is free), and so does a checkout of a project already here; - WorkspaceStatus.MediaOutdated reports frames moved at the home, or names the media could not learn yet, and the project menu offers Update media for it (tooltip text updated in en and it). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
8256b72913 |
fix: integrate phase 5a fix round 1
Taking the server's values now saves unsaved changes as a version first (desktop fix), while a conflict of format refuses that choice (merge fix): the save is skipped for a conflict of format, so a refused choice leaves the local versions as they were. A project that moves onto a newer Chronos's head with nothing of its own now adopts the home's copies of the local versions the home already held, as a replay does, since the replay no longer writes over unsent files before the base moves (workspace fix). The recovery test of a conflict met past a held version checks the versions before the one Take the server's saves first. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
1a35fcdb27 |
merge: review2-p5a-fix-desktop into phase 5a fix round 1 integration
# Conflicts: # src/Chronos.Data/Workspaces/WorkspaceSync.cs |
||
|
|
9772c2f934 |
merge: review2-p5a-fix-workspace into phase 5a fix round 1 integration
# Conflicts: # src/Chronos.Data/Workspaces/WorkspaceSync.cs |
||
|
|
6542562428 | merge: review2-p5a-fix-merge into phase 5a fix round 1 integration | ||
|
|
8027d84f7e |
fix(workspace): settle only the conflict shown, keep what a choice replaces, desktop gaps of phase 5a
Review 2, phase 5a, fix round 1 (desktop and the engine side of Resolve and Restore). - Resolve applies Keep mine / Take the library's only to the conflict the dialog listed: when the head or what differs moved since, the new conflict is recorded and asked again; Sync re-works a pending conflict instead of re-showing a stale list. Take the library's first saves uncommitted changes as a version, and the editor takes it as one undo step (toast Undo, Ctrl+Z) that brings back only the settings both changed. - Restore saves unsaved changes as a version also while a conflict waits; a restore that changed nothing, or was undone, no longer marks the next version as a Restore. - The editor's saves and merges of a workspace project merge positions photo by photo (portable form) and ask where both sides changed a setting, never deciding for ours. - Read-only after a pull is signalled, and no save that can never be stored is left behind. - The chip is read again after edits; a background conflict waits for the open dialog; Send first and Delete show the conflict they met; Discard changes needs the typed name. - Open project... reaches the library's other projects (Save both's sibling, also from its toast); copies whose project or sequence is gone read Not in library and can be removed from the picker's Workspace rows; a delete whose local copy stays says so. - A workspace folder inside a library is refused before anything is written. - Conflict and Compare lines name heroes, exclusions and keyframes; History shows the PC name alone, never the program's prefixes. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
833d7cf8e9 |
fix(workspace): every cut of a sync is recoverable, renders name only versions the home holds
A push now moves the base before its local file reads as sent; a replay journals itself in sync.json, writes the replayed versions, then the base (the commit point), and only then sets the old ones aside and adopts the local commits the home already held; a conflict met past such commits moves the base onto them first. A save-both journals its copy and the ids it sends under, so a retry completes the same copy instead of making another. The next push, pull or resolve finishes or undoes whatever a cut left, so no version is orphaned and no false conflict appears. The editor reads the working state and the media index under the project lease; workspace.json is written whole and moved into place (an empty one is made again); project files may hold 64 MiB and one that would be larger is refused before it is written, so large projects check out. The workspace copy checks the drive's free space before and during the copy, keeps the folder in its checkpoint and stores a reset when a pass starts again, and runs at High level in the priority queue. Renders record a version only when the index holds it with the settings rendered; an unsent version renders as the project. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
d940fc7c61 |
fix(projects): sidecars stay the truth when they cannot be read, are missing or newer
A project record that could not be read once, or a missing .chronos/projects, marked projects deleted for good and made a second Main; an index meeting Main with no mirror state took its own stale settings column as an outside change and reverted the pushed head; a newer-format or unreadable head made every project call fail or rewrote the record's head over the real history. Now: - Deletion is never inferred from absence or a read failure: an unreadable record holds its project back (listed as indexed, nothing written for it, no second Main), a row marked deleted is revived when its live record says so, and projects the archive has no folder for are written back from the index. - Appends re-read the record under the lease and refuse when its head is not the index's; Main is only made when the sequence has none anywhere. - An index with no mirror state decides from project.json and the record's new mirrored member (older records: the head's ancestry), never from its own column. - A newer-format Main head is listed and pulled but never mirrored, merged or built on; pushes must parse strictly and fit the one 64 MB version limit (TooLarge otherwise). - Duplicate version numbers and name/Main clashes are contained per project, so a scan or rebuild never stops. - Delete moves the folder first, then writes the deleted record in the trash. - The home's read-back for workspace pruning and Remove local copy reads the version files (IProjectHome.HoldsAsync), not the index. - A read-only archive is read without writing: its projects open from the sidecars and a sequence with no Main gets one in the index only, written back once writable. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
eac4a36a7b |
fix(projects): one photo merges as one, newer settings are never merged
A workspace copied before the home hashed or converted a photo named it differently from the versions the home made since, so a pull merged the same photo as two: frame edits were silently undone and Keep mine placed the library's value. Before replaying, the workspace media now learn the home's hashes (same frame id, size and capture time) and conversion aliases, so every side names each photo alike. Rebind also gives a renamed entry the occurrence a placement looks for, so positions on burst photos keep applying once hashed, and folds entries of one photo (in Rebind and in the merge's keyed form) instead of keeping one. Settings of a newer Chronos are no longer merged member by member with this one's: ProjectMerge refuses when both sides changed. A workspace pull keeps its local versions and working state untouched and records a conflict of format that only Save both settles (into a new project of this format); with nothing local it takes the newer head read-only. Main's catch-up leaves a newer head and settings written meanwhile as they are. When Main's catch-up merge overrides values another writer stored, that writer's settings are kept as an External version before the Merge one, so nothing is lost from the history. Unknown members inside Auto values, camera keyframes and curve points, and on pending entries once placed, are kept like ProjectSettings' Extra. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
50e28fd63d |
fix: projects and the workspace copy follow phase 4's folder and conversion rules
Phase 5a was written on an early phase 4a state. On top of phase 4b it now keeps the rules every writer of a sequence's folder follows, and keeps project versions intact through Reorganize and conversions: - ProjectService writes project sidecars, project.json and the settings only under the sequence's lease and only in a folder that holds the sequence (SequenceFolders.Holds). A folder another index moved away, or one another sequence was moved into, is refused with SequenceFolderMovedException: reads answer from the index, so no project is taken for gone, nothing is written into the other sequence's folder and the old folder is never created again. The home reports it as out of reach. Full scans and rebuilds reconcile projects the same way, and a failure there is logged instead of failing the scan. - Stored versions park positions by photo and now follow the encodings a Replace conversion (or its undo) joined through the sequence's Replaced tombstones (PhotoAlias, HomePhotos): Main's mirror, renders of a version and workspace media place them on the converted frames. ProjectContent.Rebind/SameChoices name parked photos as the frames hold them now, so a conversion or a hash since is no "external" Main version and no spurious "Modified" in a workspace, and merges see one photo. - The workspace copy job only reads the archive: it no longer runs the archive's proxy pass, makes missing proxies in the workspace, reads only a folder that holds the sequence, starts again when the folder moved or files were renamed during the copy, resumes from a checkpoint of its frames version, and refuses a workspace folder inside any library before it writes anything (Errors.Workspace.InsideLibrary). The working state keeps its positions by frame where frames stay. - ArchiveProjectHome looks for a project or version the index does not know yet in the sequence's sidecars first (an index taken back from a backup, a sequence back from the trash), instead of calling it gone. Tests cover the moved and taken folder, conversions in the archive and in the workspace, the copy refusing a workspace in a library, resuming on other frames, the alias lookup and the rebinding. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
03d32f18d3 |
feat(projects): workspace projects with linear versions, the local archive as their home
Owner review 2, phase 5a (R8): editing moves out of the library into a workspace on a fast disk, and a sequence gets several projects, each with a linear version history pushed and pulled like git. - Core: ProjectSettings keeps members a newer Chronos wrote (Extra) and reads a newer settings format read-only; ProjectContent is the portable form of a version (every frame position parked by photo, canonical text, SHA-256 content hash); ProjectBundle format 2 adds the workspace section, and a file without it is still written as format 1. JobKind.WorkspaceCopy = 20 (19 kept for Convert). - Data: migration 0009 (projects, project_versions, the render's project columns); ProjectService on ArchiveService.Projects keeps projects as sidecars first (.chronos/projects/<id>/), then the index, under the sequence lease: create, rename, delete into the projects' trash, history, push with fast-forward, idempotent repeat, divergence and hash checks. Main is made from the sequence's settings and mirrored both ways, so every older code path keeps working; outside writes become "external" versions, a mirror a crash cut short is completed or merged. Full scans and rebuilds take the projects back from their sidecars. - ProjectMerge moves from the App to Data/Projects, merges pending frames photo by photo and replays unpushed commits on a moved head. - Workspaces: WorkspaceStore, WorkspaceSync (checkout, save, commit, push, pull with replay and merge, conflicts settled by keep mine / take server / save both, restore, status) and the WorkspaceCopy job (proxies copied hash-verified and resumable; originals refused until phase 5c). - Renders of a project version place its positions on the frames and record the project and version. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit c4c1802884e403db8759ed0501f770a67a047f20) |
||
|
|
e3cbe30b29 |
fix: conversions on the released phase 4a keep out of folders a sequence left
Phase 4b and its first fix round were written on phase 4a before its rounds 4-6. Moved onto the released 4a, the conversion now follows 4a's rule for writers into a sequence's folder (SequenceFolders.Holds), and the parallel fixes meet: - The job leaves a sequence another index moved away (its folder missing, or holding another sequence's sidecar) as Blocked with Errors.Archive.FolderMoved, nothing settled, staged or replaced there; the retry after this index's scan converts it where it is. It read the sidecar there and reported the reader's technical text. - New sequence reads the source's project under the source's lease, where its sidecar was just read as its own, and writes the new sequence's project under that sequence's lease only into a folder that holds it. It read the project from the folder the row named afterwards, without a lease, and wrote through the store without the check. - Download originals (resolved in the cherry-pick of the trash and sync fix, tested here) swaps a copy fetched in another encoding into its missing frame after the transfers, as round 6 restores originals, and only once the sequence is found in the folder the index has; otherwise the copies stay staged and the job fails with FolderMoved after its other work. The swap ran inside the transfer loop and failed the job at the first refusal. - The New sequence wording of the three skip reasons the codecs fix added (Archive.Convert. NotCopied.EightBit, ColorProfile, TooLarge, en and it): the server and the desktop look them up by reason. - The server's free space test sets the staging folder's figures too: the job fix measures the tighter of the archive root's and the staging folder's volumes. Tests: a conversion of a sequence another index moved (its folder taken or empty), and a download whose missing frame takes the server's conversion where the sequence is now. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
8174852a2c |
fix(server): keep convert dry runs like Reorganize's, say what a new sequence lacks
The convert endpoint planned the whole selection inside the HTTP request, again for every mode, quality keystroke and confirmation, with no limit: behind a proxy an all-sequence conversion could never get past its dry run or its apply. - ReorganizePlanCache becomes PlanCache, shared by Reorganize and Convert: one plan per key made apart from the request, two at once across both kinds, eight kept, 15-minute timeout, 5-minute lifetime, 503 plan_dropped. Keys are typed records (ReorganizePlanKey, ConvertPlanKey) that also say which exceptions are refusals. - A conversion plan is keyed by archive, a convert stamp of the index (SequenceRepository.GetConvertStampAsync: the Reorganize stamp plus, per planned sequence, the photos' count, sizes, formats, pixel sizes and missing, corrupt, preview-only and undecodable flags), the sequences and the target with the quality that counts. Not the mode: the request's mode and options are set on the kept plan, and the free space is measured again at every request through the engine. A plan made while the volume was away is not kept (503 archive_offline). - New sequence holds the converted copies alone: the dry run says the skipped photos are not copied into it (Archive.Convert.NotCopied.*, Server.Convert.OnPcNew), the panel's totals, column and confirmation give the count, and so does the desktop's summary. - Panel: the preview is asked in Replace's neutral words; a dry run cut off by a proxy is asked again while the totals show how long it takes, plan_dropped is retried once; an apply the server let go plans again, a changed one shows Admin.Convert.PlanChanged, and one with no answer is not resent (its job may be queued). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit f0b1e379ce7c08b6d3459ab25ca6214c8f366f6c) |
||
|
|
d0bbd77c92 |
fix(archive): settle conversions by content and keep their aliases through trash, undo, sync and ingest
Owner review 2, phase 4b, fix round 1 (trash, undo, recovery, sync and ingest). - Replace journal: records a phase (moving, written, undoing) and the name each swapped frame is filed under. Recovery decides "sidecar written" by what the sidecar lists, not by the frames version any writer moves; a failed rollback stays undoing and its failure now stops the writer (as a photo deletion's recovery does). The ingest settles restores and replacements first, so an upload can no longer complete a swap that never happened. - Emptying a Replaced entry re-verifies each replacement where it is now: in the sequence through later conversions (a second conversion no longer strands the first originals), or, when the conversion was deleted, its copy in the trash. The dry run marks such entries "conversion deleted" (fingerprinted, shown on the desktop and the panel), and the confirmed emptying may then erase them instead of keeping them forever. - Undo of a conversion takes exactly the entries its job made (the job id is recorded on the entry), never entries found by time window. - Project positions translated by photo use the sidecar's photo of every frame still there, so positions on a converted frame stay put when another frame went meanwhile. - Sync aliases are equivalence classes: an original converted on both sides is one photo; link-by-content, proxy counting and proxy upload follow aliases; a download into a frame missing here swaps the other encoding into that frame instead of adding a frame. - The ingest answers a converted photo's original (a card or folder imported again, a download) as a duplicate of its conversion and keeps the alias tombstone. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 3341a2f845753fc4c5bcba51a3b645f126c95eaf) |
||
|
|
67a6d51cbe |
fix(archive): convert job applies exactly the confirmed plan, resumes safely and watches its space
The convert job planned every sequence again when it ran and checked only the frames version, so a verify, a repaired upload or a tier change between the dry run and the job let it replace photos the confirmed plan had listed as staying unchanged. - Each sequence of a convert job now carries the digest of the photos it converts, each with its SHA-256 (ConvertSequencePlan.Digest, also in the plan's fingerprint). Under the sequence's lease, its sidecar settled, the job plans it again and goes on only while the digest matches; it then pins those photos (convert-<job>.pins), so photos that come in or are verified later stay as they are, a retry included. Stage B checks under the lease that every pinned photo still holds the content converted instead of holding the frames version, so a sequence still receiving uploads converts what was confirmed. - A resumed job settles the journals a crash left in a sequence (a half-done replacement among them) before it plans, and reports a sequence its replacement completed as Converted, never Nothing or a partial swap. - The passes a converted or new sequence needs are queued as soon as its outcome is journaled; the journal records the statuses they follow from and whether they were queued, so a pause, yield, stop or crash no longer loses them. - Staged conversions of a blocked or failed sequence are kept for the retry, which re-verifies and takes them; maintenance keeps a convert job's staging while the job is queued, running or paused, and removes its journal and staging once the job is done or gone from the history. - A dry run counts the sequences of a queued conversion as busy, so the same conversion cannot be confirmed twice. - New sequence copies are owned by the source's owner, else by the requesting user's id (never the user name); a staged copy that vanished fails the sequence instead of leaving its photo out; the job log states how many photos stayed in the source alone. - Free space is measured where the conversion writes: the server takes the tighter of the space path's volume and the archive's own (Unraid cache), the desktop asks Windows (GetDiskFreeSpaceEx), which also measures UNC archives; the job checks again before each sequence and each photo, scaling estimates by the files staged so far, and stops before the volume fills with what it staged kept. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 2d7d461c33b9f257bf57793cc7cf331d0425c14e) |
||
|
|
f86a151a5d |
fix(convert): keep what the original holds and plan only what converts
Phase 4b review, codec findings. A Replace makes the converted file the photo, so a conversion must not lose what the original held, and the dry run must promise only what the job will do. - Linear DNG from a conversion is scene-referred: the pixels are stored in linear ProPhoto primaries (colours outside sRGB stay positive) and divided by the power of two that brings their peak under the white level (at most 4 stops), with BaselineExposure giving it back and ColorMatrix1/ForwardMatrix1 describing that space. Highlights a RAW develops above 1 and its wide-gamut colours now read back as written. Exports keep the clipped linear-sRGB DNG. - A conversion reads with the managed decoders first for every format they read natively (RAWs developed at float precision, as on the server) and with WIC only for what they cannot. A RAW only WIC's Raw Image Extension develops (8 bits) is refused for TIFF-16 and linear DNG and planned out as "eight_bit"; JPEG still converts it. Providers say so through IImageDecoderProvider.DevelopsRawAt8Bits. - The original's colour space is kept: a JPEG (APP2) or TIFF (tag 34675) carries its ICC profile, with the values unchanged; a linear DNG gets the values converted through a matrix/TRC profile; a gray profile converts to sRGB. Exif Adobe RGB (uncalibrated + R03) and HEIF nclx P3 get an in-house profile. A space nothing here can keep (CMYK, a lookup-table profile into a DNG, uncalibrated without R03, HDR nclx) is planned out as "color_profile". New in-house ICC parser/writer and header reader for JPEG, PNG, TIFF, HEIF/AVIF and WebP. - The planner asks every file, whatever tier was recorded (unknown before the light analysis, or by another host), with the conversion's decoders, headers only and eight at a time; a RAW the server cannot develop is "convert_on_pc" in the plan instead of failing its sequence. Photos a target cannot hold (a JPEG side above 65535, more samples than one buffer) are planned out as "too_large", and an overflow fails its photo rather than the job. - A photo that fails reads in the job log as one catalog sentence by cause (Archive.Convert.Failed.*), the file named once; the exception's English text goes to the diagnostics log only. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 0ca1e91ea09946d7a55f45695ee58e1a0ff5f779) |
||
|
|
341fb77507 |
fix: conversions name, lock and settle as phase 4a's writers do
Phase 4b was built on phase 4a before its review fixes. Integrated on the reviewed 4a, the
conversion now follows the same rules as filing and the other writers.
- Names: a converted file is named as filing names a photo of its sequence (FrameNaming: the
archive's file template, the frame's context in the sequence with its camera, lens, number
and title, {name} the card's, {ext} the target's, a long name keeping its extension).
Replace through ConvertOptions.FileName; New sequence through the ingest itself
(StagedFrame.NamedAs), which numbers and names the copies in the new sequence. Names stay
unique against every file present, those leaving included, so a Replace never moves onto a
file; a test pins a stray file that keeps its bytes.
- Leases: stage A starts from the sidecar settled under the sequence's lease where the index
has it then (SequenceWriter.ReadLocked), and FrameTrash.ReplaceAsync reads the row again
under the lease, so a folder a Reorganize moved meanwhile is followed, never made again.
A Reorganize the archive waits for keeps the conversion off its sequences (pinned).
- Journals: the replace journal is settled with the others. MassRenamer steps, restores into
a sequence and sequence deletions wait for an unsettled replacement as they wait for a
restore, and so do photo deletions, whose frames version the recovery reads
(FrameTrash.EnsureReplaced); a scan settles it and reconciles nothing meanwhile; a restore
settles its sequence's replace journal first, at the folder the index has under the lease.
- The convert job tells each sequence converted or made as it completes, as a Reorganize
tells each step, so an editor open on it reads it again while the rest of the job runs.
- Desktop: JobKind.Convert gets its row in the settings' job priority list. A click on Apply
that commits the quality no longer starts the same dry run again under the click (as 4a
fixed for Reorganize).
- Panel: a dry run answered during the confirmation with the same plan no longer drops the
confirmed Apply; a different plan is shown with Admin.Convert.PlanChanged (en, it).
- Tests: TrashDialogTests.EmptyQueuesTheJobOfTheConfirmedPlanOnly waits for the command to
end before running it again (a running AsyncRelayCommand ignored the second Execute).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 2e0d1d6dcc10575734970bb9c77749f00777c859)
|
||
|
|
0e52929274 |
feat(archive): convert sequences to JPEG, TIFF-16 or linear DNG after import
Owner review 2, R7 asks for mass conversion after import on the web panel and the desktop, with a choice at every run between Replace and New sequence. This is the engine and the server API both UIs build on. - Core/Conversion: ConvertOptions (JPEG 4:4:4 at quality 1-100, default 95; TIFF-16 sRGB Deflate with the predictor; linear DNG, the archival choice; converted names keep the stem and take the target's extension in the old one's case). FrameConverter decodes at the native tier only, encodes with the in-house writers, writes Exif from the sidecar (capture time to the tick, offset, exposure) and the original (camera, serial, lens, modes, GPS), hashes the bytes as made, writes atomically and verifies: read back, the metadata again, a decode by the server's decoders. ExifWriter now writes the exposure program, metering mode, flash and white balance. ConvertPlanner: convertible frames, skips with reasons, size estimates per pixel, the plan's space and fingerprint. - FrameTrash.ReplaceAsync swaps the files of frames in place: same ids and indices, the old files and their XMP companions into one Replaced trash entry (records, replacement hashes, a copy of analysis.json), tombstones aliasing old content to new, proxies of the swapped frames dropped, under .chronos/replace.pending.json, which the next writer undoes or completes. Restoring a Replaced entry swaps back while every converted frame is unchanged (the converted files become a Replaced entry in turn), else the originals come back as a new sequence. - MassConverter and JobKind.Convert (19): the dry run (busy, offline, unreadable, space against ArchiveServiceOptions.FreeSpace), stage A converting into staging/convert-<job>/ in parallel with each source re-hashed and each staged file appended to journal/convert-<job>.staged, stage B per sequence all or nothing under the lease at the planned frames version: Replace, or a new sequence through the ingest with the source's tags, rating, notes and project. Resumes keep verified staged files; a sequence changed, busy or with a failed photo is left as it was and fails the job at the end, the journal kept for a retry. - POST /api/v1/archive/convert: dry run with the plan, its space line and fingerprint, or a 202 convert job; formats the server cannot read at full resolution are skipped as convert_on_pc; validated, audited (archive_converted), sequenceChanged converted/created. The server measures the space volume for the check. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 809210d924cfc3f597ecdea26106fb3ff62d3762) (cherry picked from commit e13d4c0bb1bd9441933b6f3e5b6220e865a7228c) |
||
|
|
f8c445fac3 |
fix(archive): a third sequence's export follows its file; resumed renders and restored originals stay out of folders a sequence left
Round 5 stopped clearing "behind" for rows of a third sequence (neither the one moving nor the one now holding the old folder). Such a row, an export one sequence saved in another's exports through the Export folder picker, then stayed at its old path whenever the sequence that moved into the folder brought an export of the same name, and named that sequence's file (Send exports would upload it). A file at the old path is never "behind" while the old folder holds another sequence: it is that sequence's, so every row other than the holder's follows its file. A resumed render job deleted the output its crashed attempt was writing at the absolute path in the checkpoint. After another index moved the sequence away and another sequence into the folder it left, and this index scanned, that path named the other sequence's export. The checkpoint now keeps the sequence's folder when the output was chosen; a pending output there is rebased into the folder the sequence is in now, one in the sequence's current exports or outside the archive (an export folder chosen on a client) is discarded as before, and one anywhere else in the archive is left alone (the entry renders under another name). Older checkpoints, without the folder, only discard in the current exports. Download originals put an original flagged missing back at the path read before the transfer, with no lease and no check of the folder: after another index moved the sequence, it recreated the folder it left or filed the photo among another sequence's originals. The restores now run after the transfers under the sequence's lease, in the folder the index has then, which must hold the sequence (SequenceFolders.Holds), at each frame's path read under that lease. Otherwise nothing is restored, the copies stay staged for the next attempt and the job fails with Errors.Archive.FolderMoved after its other work. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit ad46ef68180845de4b9b605a4ce2529a148c6f13) |
||
|
|
8c2b9f1bfe |
fix(archive): a rebase moves no row of the sequence that took the old folder; writers refuse a folder another sequence holds
Round 4 let every row under the old folder follow when that folder holds another sequence now. When the scan took the new holder first, its own row (already rebased into the old folder) then followed the moving sequence too and named that sequence's file, leaving its own export without a row; a second scan did not repair it. Only the moving sequence's own rows now follow because the old folder is taken, and a row of the sequence holding the old folder never follows: its export is in its own folder whatever the other one took along under the same name. The rebase callback now gets the owner of each row. Writers that file into the folder the index has for a sequence checked only that the folder existed. After another index moved the sequence away and another one into that folder, Take server wrote the server's settings into the other sequence's project.json, Save both wrote this PC's copy into its .chronos, and a render sent for the sequence was filed among its exports. SequenceFolders.Holds treats a folder whose sidecar names another sequence exactly like a missing one, and every such writer asks it: settings sync and conflict resolution (Errors.Archive.FolderMoved), Save both's copy and its clean-up, server render filing (503 folder_moved, the upload kept), export downloads, render jobs as they start, proxies sent and proxy passes, the deep analysis checkpoint and the editor's project save. A thumbnail pass refuses a sidecar of another sequence before it opens the pack. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit b406a4f6a9a7a3121e9e40289663fb62ee31948e) |
||
|
|
964b996af2 |
fix: keep pre-rule templates through web settings saves; retry render filing after another index moved the folder
The web panel's archive settings save checked both request templates against every template rule before the engine ran, so an archive.json saved before the rules made every save fail, even of the name or proxy size. Only a template that differs from the stored one is now held to the rules, as ArchiveService already does, and a TemplateRuleException from the engine (archive.json changed since the form was read) answers invalid_template with its rule instead of archive_policy. Exports follow a moved folder correctly in two more cases. Image-sequence exports are folders, so the rebase now tests Path.Exists instead of File.Exists. An export left at the old path no longer pins a sequence's row when that path now belongs to another sequence (its sidecar holds the old folder, or its render row names the path); the row follows to the new path, so it never names another sequence's file. RenderStore throws FolderMovedException when the sequence is not in the folder the index has. That is transient until this index's next scan, so client render uploads and render-node results now answer 503 folder_moved, keep the part file and the node's job, instead of failing them for good with a wrong reason. Save both and Take server refused because the folder moved now say Errors.Archive.FolderMoved (try again after the next scan) instead of the "changed again, choose again" sentence, which repeated until a scan. Doc wording: the ReorganizeDialogViewModel summary covers a sequence kept whole, and RenamePlanner.Plan's existsExactly says the own folder is found under at most one of the two names. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit d898798657197d48f4e19b7f776003eb2fc441b5) |
||
|
|
d0da224de5 |
fix(reorganize): take along a sequence left inside a moving folder; keep a plan whose archive is offline
A selected sequence nested in another selected sequence's moving folder moves out first. When the templates no longer gave it its folder (its first photo gone, or an earlier one filed), it stayed inside, and the outer step then found it as a stranger: StaleRenamePlanException at every retry, the plan held forever. - A moving folder now takes along the sequences of earlier steps that stayed inside it (their index row still there): locked, moved and recorded with it, keeping their title and file names. They are reported TitlesKept instead of Dropped; a carried sequence whose carrier stayed is simply changed (or TitlesKept when it was to change more than its folder); Newer stays Newer. RefuseStaleAsync exempts exactly those, so a held plan either fits or is given up. - MoveJobHandler: a journal not found on an offline archive tells nothing. A failed job keeps its plan:<id> checkpoint instead of becoming 'applied', and a retry while the archive is offline fails with "archive offline" instead of logging ReorganizedEarlier and ending done. - The Fit.Names warning now says what happens to the folder (moved already, carried, or not moved to the planned one); stale ApplyAsync, RefuseStaleAsync, FitAsync and job docs corrected. Tests: the nested case (fresh run and held retry, three levels), the same through a held job, a carrier named otherwise with a carried sequence, Fit.Names on a resumed step whose folder moved (held and not), and an offline retry that keeps its plan and completes it once the archive is back. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit c5ffc87f1a3900442920693763fd04d28cb43aee) |
||
|
|
1fb040afe6 |
fix(server): a verify that hashes photos plans Reorganize again; keep refusals, bound planning
The kept-plan stamp left out whether a planned sequence's photos are hashed. A verify writes frames.sha256 (and only status and verified_at on the row) without another frames version, so after verifying never-hashed photos the same dry run kept answering "verify the sequence first" for up to five minutes, and its confirmation queued a job certain to fail. - SequenceRepository.GetStampAsync adds, for every planned sequence, how many of its photos have their hash in the index (one grouped query over the archive with all, the selected ids in batches of 500 otherwise). - ReorganizePlanCache keeps a refusal (nested_target, not_found) as it keeps a plan: for the same stamp and templates it is the same, and a long plan that ends refused after a cut-off is no longer planned again on every retry. Failures are still not kept. - Planning is bounded: at most two plans are made at once, the others wait for their turn; a plan still being made 15 minutes after it was asked, let go at capacity, or when the server stops is cancelled, and whoever waits for it gets 503 plan_dropped. A read that hangs keeps its turn until it returns but no longer keeps its waiters. - The Capacity summary now says what eviction does (the kept plan asked for first, else the plan being made asked for first); the stamp, protocol and endpoint docs say that a verify hashing photos is a change the plan reads. - Tests: a scan's photos, verified, are planned again and renamed by the job; the stamp follows hashes of planned photos only; refusals kept, failures not; turns, eviction and deadline of plans being made, a hung read included. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 56582df45453fc555e525f19de7de1803204d12c) |
||
|
|
c3756d03c9 |
fix: keep render filing retryable and writers out of a folder another index moved
Third fix round of owner review 2, phase 4a (Reorganize), cross-cutting items. - Server render filing now runs under the sequence lease, so it can meet a busy sequence or an offline archive. Both completions (client render uploads and render-node results) used to answer 500 and leave the upload stuck in Committing until a restart. They now answer 503 sequence_busy or archive_offline, which clients retry. The upload goes back to receiving with its part file and the node keeps its job (UploadService.ReceiveAgainAsync). - Save both: when this PC's copy cannot be written (another index moved the folder), the server's version is no longer applied, even if this index's scan relocates the row before the apply would run. A copy that has to be dropped is deleted from where the folder is now, as a best effort. - Export rebase on a folder move (scan and Reorganize): the sequence's own export follows the folder unless its file is still at the old path and not at the new one. A file written into a re-created old folder therefore keeps a row that finds it, so the file is never stranded. - A render job refuses to start when its folder is not where the index has it, which also stops it from re-creating the old folder. Renders fetched by sync are now filed under the sequence lease into the current folder, or not at all (new string Errors.Archive.FolderMoved, en and it). - The proxy pass holds the thumbnail lease one batch at a time (a quarter of the lease wait), then lets it go for longer than a waiter's poll and reads the folder and sidecar again. Before, another process's Reorganize, sequence deletion or pack compaction could wait out its lease wait and fail. Updated the stale comments on that lease and ARCHITECTURE.md to match. Tests cover each fix, and each new test fails with its fix reverted. Also covered: proxy store and pass in a moved folder, RenderStore with the folder gone, Take server with the folder moved, and an editor save with the folder moved. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 811509d32a118ed50ad10d47d4b002e534da9d77) |
||
|
|
0377040a19 |
fix(archive): a case-only target that is the sequence's own folder is kept; stored templates never fail other edits
Reorganize refused a case-only folder target whenever a folder of that exact name was on disk. On a case-insensitive file system that folder can be the sequence's own, when the disk spells it as the template does and the index does not (renamed in Explorer, or an outer level a change of case left as it was), so the plan gave a needless " (n)" folder. RenamePlanner.Kept now refuses only when both exact names exist, the condition MassRenamer.TargetTaken and MoveFolder already use. ArchiveSettings.Problem held both templates to the template rules on every UpdateSettingsAsync, so an archive.json saved before the rules made every desktop Settings > Archive edit fail. A template the file already holds is now only checked for being usable; a template the edit gives, and both templates of a new archive, meet every rule. A broken rule throws TemplateRuleException (an ArgumentException naming the field), and the desktop toast shows that rule's sentence instead of "Something went wrong". Also corrects comments that ignored RenameBlock.Unreadable (the whole sequence stays as it is) and the ARCHITECTURE Naming row. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit ac7a0c36df83b6d43651caf0225c530466242c97) |
||
|
|
8127373fd5 |
fix(reorganize): never name a folder or title after a photo no longer first, and retry a kept job honestly
A Reorganize step whose photos changed after the plan kept its file names but still moved its folder and wrote the title the plan had computed from the old first photo, so a trashed first photo or an earlier photo filed since left the sequence named after a photo that is no longer first. The plan now journals its folder and title templates, and under the step's leases each folder move or retitle is expanded again from the settled sidecar: it is applied only when it gives what the plan gives (the folder itself or its " (n)"); otherwise the sequence stays as it was (Dropped, "changed after the plan"), or keeps its title and file names when an interrupted run moved its folder already (TitlesKept). Plans journaled before this change are applied as made. A Move job that ended failed with sequences kept, or whose held plan was given up, kept its plan:<id> checkpoint after the plan's journal was gone, so a retry logged "completed when the archive was opened" and ended done. Such a job now saves the checkpoint "applied": a retry plans again and applies only a plan that is still the one confirmed. A job that succeeds keeps plan:<id>, so a crash before it is marked done still finds the plan completed. Sequences a folder was to carry when that folder stayed (dropped, its title edited, its names no longer given, or a newer sidecar) were reported as "changed after the plan", and a newer-format carrier failed the job with ReorganizeKept. They are now a separate outcome, CarriedKept (journaled), logged with the new Archive.Log.ReorganizeCarriedKept (en+it) and not counted in the job's error, which follows the carrier's own reason. When a step's sidecar cannot be read or written after its folder moved, every sequence of the step is told (sequenceChanged "reorganized") before the failure is thrown, since the retry that would tell them may never come. Tests: Core APlanKeepsItsTemplatesSoTheNamesOfAFirstPhotoNoLongerFirstAreTold; Data AFolderOrTitleNamedAfterAPhotoNoLongerFirstIsNeverGiven, ARetryOfAJobThatKeptSequencesPlansAgain, ASequenceAFolderWasToCarryIsToldItStayedWithIt, AnArchiveOpensWhenAnInterruptedRenameMeetsASidecarOfANewerFormat, AResumedStepWhoseFolderMovedKeepsATitleEditedSinceAndTheNamesFromIt, and AMovedFolderWhoseSidecarCannotBeReadThereHasItsIndexRowFollowAndIsTold, which breaks the sidecar with a relative symbolic link instead of a read-only file, so it also runs on the Linux runner as root. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 130701afab224d47ea066eb7cc8debb16d1fb432) |
||
|
|
37800b28ef |
fix(server): key kept Reorganize plans on what they read, plan apart from the request
A kept dry run was keyed on a stamp of every sequence row of the archive, updated_at and verified_at included, so any upload, ingest status write, verify or tag edit anywhere invalidated it and the confirm planned the whole selection again. The plan was also bound to the request, so a proxy cutting the request off cancelled it and a retry started over. - The stamp (SequenceRepository.GetStampAsync) now hashes only what the planner reads from the index: every row's id and folder (collisions and what a moving folder carries), the planned rows' title, first capture, camera, lens, photo count and frames version, and the titles of the rows inside a planned folder. With all, every row is planned. - ReorganizePlanCache makes a plan on the thread pool with the host's stopping token, once per key for concurrent requests; a request cut off only stops waiting, and the same request again waits for the plan or takes it. Refusals and failures are still not kept. - A kept plan is dropped by its own timer five minutes after it was made (and never used past that), instead of staying until the next request. - The protocol and endpoint docs say that plan_changed answers changes the index has; one made on disk alone is found by the job, which fails and changes nothing. The Capacity doc no longer claims a step per sequence. - Tests: what the stamp follows and ignores, a kept plan surviving an upload elsewhere and a verify, one plan for concurrent requests and after a cut-off, the timer, an all:true apply carrying a nested sequence beside a blocked-only one, the first sequence told before a pause. The no-archive-module job_unavailable test expected a folder the planner no longer plans without a sidecar; it now expects the unreadable step. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 7e01a4f85fe4b880ddd98a481fc8591649cec254) |
||
|
|
6e99a4b269 |
fix(archive): exports follow a folder any index moved; proxies, exports and copies no longer recreate it
Second review of owner review 2, phase 4a (Reorganize), cross-cutting findings. - A second index of the archive (a desktop sharing a server's archive, or a folder moved by hand) moved the sequence row at its next scan but left renders.output_path at the old folder: the export answered 404 there. The scan now rebases the render rows in the same transaction when it finds a sequence in another folder. - The rebase covers every render of the archive under the old folder: the sequence's own exports always, and another sequence's export saved inside it (through the Export folder picker) when its file moved with the folder. That check keeps the exports of a sequence that took the old folder since (a later Reorganize on the other index) where they are. A change of case only counts as a move. - The desktop now tells an open editor after each Reorganize step (ArchiveServiceOptions.SequenceChanged -> AppServices.SequenceReorganized), and the editor reads its sequence again where it is now, so frames no longer decode blank until the next save. LocalSequenceSource.LoadAsync also requires the same folder on both row reads, so a move that commits during the frame listing is never taken as current. - Writers that wrote without the lease, or trusted a row another index had moved, could create the old folder again. A proxy sent by a client is now filed under the sequence's lease into the folder the index has then, and a gone sequence or folder answers 404 (sequence_busy 503 after the lease wait). The server files a render a client or render node sends under the lease (ArchiveService.UnderLeaseAsync). "Save both" keeps its copy under the lease. The proxy pass holds the thumbnail lease, as the thumbnail pass does. The deep analysis opens its checkpoint under the sequence lock only while the folder is still there, and a pass whose folder another process moved records nothing (the job logs Advisor.Log.FramesChangedElsewhere). Editor saves and sync applies refuse when the folder is gone. - ARCHITECTURE.md no longer claims more than this: a render of another process whose folder moves while it runs is still not stopped. - ArchiveVerifier.FlushAsync: corrected the comment. A move keeps each file's stamp, so only a check that found the file missing no longer applies. Tests cover the scan path with a later swap into the vacated folder, another sequence's export inside a moving folder, a photo deletion refused when the folder moved while it waited for the lease, proxies sent and made after a move, Save both during a move, a deep analysis whose folder another index moved, a render filed after a move on the server, and an open editor reloaded by a Move job. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit c857b98f795b22956c060f1c5acf4d94b6d1c994) |
||
|
|
765f0ad36b |
fix(archive): Reorganize never plans a move onto a folder of the exact name, keeps long names' extensions, says why a template is refused
Second fix round of owner review 2, phase 4a (planner findings).
- A sequence keeps a folder that differs from its own in case only while no
other folder holds that exact name (RenamePlanner.ExistsExactly, every level
compared exactly). On a case-sensitive file system a stray "Trip (2)" beside
the sequence at "trip (2)" no longer gives a case-only step that MoveFolder
refuses at every archive open: the plan gives "Trip", and a plan whose
target appeared since is refused under the step's leases before anything
moves (or dropped when it resumes). A change of case in an outer level no
longer looks like two folders on Windows.
- A file name longer than 200 characters is shortened before the ".{ext}" the
template ends with, never through it, so a long title never strips the
photo's extension.
- The archive engine's own settings check applies the template rules the
server and the desktop apply (a folder scans skip, a lost extension, names
that repeat), so archive.json can no longer take such a template.
- The server's invalid_template answer names the rule after the field
("fileTemplate:extension") with the desktop's sentence as its message; both
admin panels show it on the field.
- FrameNaming keeps only the naming overloads production uses.
- Comments about Unreadable say the whole sequence stays as it is.
- Tests pin filing against Reorganize: an upload without a capture time, a
card's second session with {session}, a duplicate skipped mid-session, and a
whole folder of two cameras named with the first one's camera.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 50fe59aec1e180daa1733bcb951892a79dceba6c)
|
||
|
|
9e1f109b58 |
fix(reorganize): a sequence still receiving photos keeps its file names and the job goes on
A Reorganize with a file template failed its job at the step of a sequence
a camera was still uploading into, and its retry gave the rest up. Photos
changed since the plan now never refuse a step: that sequence keeps its file
names (FilesKept), its folder and title change as planned, the other steps go
on and the job ends with ReorganizeKept. The fingerprint, the job's
confirmation and the check under the leases pin file renames by their digest
instead of the frames version, so photos filed under the names the plan gives
them no longer make a dry run or a queued job stale.
- A step whose folder or files a template names after {title} checks the
title as a retitle does (RenameStep.NamedByTitle): no name comes from a
title edited since the plan.
- Recovery sends a photo that already took its new name back together with a
companion whose new name was taken, so the two never end up apart.
- ArchiveService.OpenAsync logs a NewerFormatException from resuming a plan
and keeps its journal, so a server still boots.
- Once a step's folder moved, every index row of the step follows it even
when a sidecar cannot be read or written; the step then fails for a retry.
- Job log lines and errors give the real reason for files kept busy (in use
or a new name taken) and for a sidecar of a newer format (new Newer
outcome; strings en and it).
- A plan an archive open completes tells sequenceChanged; the docs that
promised more than that are corrected.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit f8554b8af0828ab9b0ff128e694abacdd53e6fd7)
|
||
|
|
9ae773aa5a |
fix(server): keep Reorganize dry runs for the confirm, test the protocol's key paths
An all:true dry run reads every sidecar and photo folder of the archive inside the request, and the confirm planned the whole archive again before answering 202. The server now keeps each dry run's plan for five minutes (eight plans at most) by archive, selection, templates and a stamp of the archive's index rows: the same dry run again and its confirmation take the kept plan, and any change the index records (an upload, an edit, a move, a scan, a verify) gives another stamp and a new plan. A change made on disk alone is not in the stamp; the move job still plans again and refuses a plan that no longer matches. Server tests now cover an all:true apply around a sequence already in place, a real plan_changed after an upload, a move job paused between two sequences and resumed, archive_offline, job_unavailable, more than 1,000 ids and the kept plans themselves; a Data test covers the index stamp. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 71bb53fbf8eb7d0327ea692d046634b12f8d37e9) |
||
|
|
9ce201cd70 |
fix(archive): exports follow a Reorganize folder move; writers resolve the folder under the lease
A Reorganize step that moves a sequence folder carries its exports/ with it, but only the sequences and frames rows followed: renders.output_path kept naming the old folder, so the server answered 404 for the export, Get/Send exports and Reveal lost it, and no scan or trash restore could repair it. RenderRepository.RebaseFolderAsync now rewrites the archive-relative output paths of the step's sequence in the same transaction as the frames (idempotent on resume; absolute outputs and the archive root are untouched). Writers that read a sequence row before taking its lease wrote into the folder a Reorganize had moved meanwhile, creating it again (project.json from the editor or a sync, a thumbnail pack) or failing on its missing sidecar. They now take the folder from the index row read under the lease (SequenceWriter.FolderAsync): the editor's save refuses with FramesChangedException and reloads at the new folder, FramesCurrentAsync reports a moved folder, and the sync apply, project store, thumbnail pass and its status, decode tiers, analyses, verify, info edits, ingest, duplicate flags, pack compaction and photo restores write where the sequence is now; a photo deletion planned before the move is refused as stale. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit be28d8acf0d96012c94a266f8af61e9bbafaa28d) |
||
|
|
b253cac8d4 |
fix(archive): Reorganize names as filing does and refuses templates that lose or hide photos
Reorganize with the archive's own templates planned renames and moves for
photos just filed, and some templates could strip extensions, hide sequences
from scans or stall a dry run. Owner review 2, phase 4a findings.
- Filing and Reorganize share one context: uploads and imports name every
photo with the sequence's camera and lens (its first photo's, or the
creator's hint), an upload's folder from its first frame in the new
sequence, and a missing capture time from the sequence start instead of
the current time. The planner expands folder and title templates from the
first frame in the sidecar ({name}, {ext}, {iso}...), never today's date.
- Titles expand as text (ExpandText): "Paris: night" stays as typed.
- A sequence whose sidecar cannot be read (torn, another sequence's) keeps
its folder, title and names, listed with why, and so does every folder
around it; the dry run reads every sidecar, nested ones included.
- Kept never gives one folder to two sequences of a plan whatever the case,
and a case-only move onto another folder is refused instead of taken as
done.
- Shared template rules (TemplateRules) for the server's Reorganize and
archive settings and the desktop's fields: a file template must keep the
photo's extension ("{n}{ext}" refused) and tell a session's photos apart;
a folder template may not write a level scans skip (a leading dot,
originals, proxies, exports). Levels a title gives are escaped with "_".
- {ext} comes from the file, or from the original name when the file lost
a photo's extension, so a Reorganize can put it back.
- Unique names cost linear time (UniqueNames) with the same names as before.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 6c734777e01476881a3f34b3188571cc3f7150ab)
|
||
|
|
13c2ac321c |
fix(archive): Reorganize checks each step before it moves, holds a failed plan, recovers file renames safely
Owner review 2, phase 4a review findings on the renamer. - File rename recovery is safe to run again from wherever it stopped: once every file is at its temporary name the journal says phase 2, as Run does, so a second recovery (after a failure, a crash or a sidecar that could not be written) never moves a file that reached its new name. A new name something else took meanwhile is never written over: that photo and its companions go back to their old names, or to the first free _2, _3, recorded in the journal before they move, and the frame names where its photo is. A journal is never deleted while a temporary file of it is still there. - Every check that can refuse a step runs under the step's leases before anything of it moves: where its sequences are, strangers inside, its new folder taken since the plan (a restore, an upload), a sidecar of a newer format, a title edited since the plan (compare-and-set against the planned from-title, sidecar and index), and its file renames, compared by a digest of every move at the planned frames version (a verify that hashes photos does not bump the version). Once the folder moved, every index row follows it before any file is renamed, and a photo in use or files found changed keep their names: the step completes. - The same checks run up front for a held plan, so its retry either fits or is given up. - A failed move job holds its plan, as a pause does: an archive open no longer applies the rest unasked; only the job's retry does. File renames a step left half-way are still completed at an archive open. - Each sequence changed is told as its step is journaled, so a pause or a failure never keeps it untold; the plan's journal keeps the tally of every run, so the job log counts the whole plan. - A selected sequence deleted while the job waited is named in the log and the plan refused with the localized stale-plan error, not a raw ArgumentException. - The dry run renames no file of a newer-format sidecar. New log lines and error (en, it): title and file names kept, file names kept because a photo was in use. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 1d1c888120edd709dbb5341c1922bf85085c4857) |
||
|
|
950524929c |
fix(archive): stable Reorganize folders, settle trash restores first, retranslate Reorganize
Integrating owner review 2 phase 4a (R7) onto the reviewed phase 3 code. - RenamePlanner: a sequence already at its expanded folder, or at the " (n)" of it that filing or an earlier Reorganize gave it, keeps that folder (in the template's case, unless another sequence holds that exact name). The planner seeded its claimed folders with the sequence's own, so "2026-09-28 (2)" was planned to "(3)" and back to "(2)" by the next run; a second Reorganize with the same templates now plans nothing. - MassRenamer: each step settles what a crash or a busy trash entry left in its sequences (SequenceWriter.ReadLocked) and waits, as a sequence deletion does, while a restore from the trash is not settled (FrameTrash.EnsureSettled), before its folder or any file name changes: that restore's journal names files by the names they had. Trash records keep restoring after a Reorganize: into the sequence where it is now, under the record's own name made free (_2) with its companion following. - Jobs.Kind.Move and Admin.Job.Kind.Move now mean "Reorganize": their old "Move archive" translations are removed from the 36 other cultures so they are translated again. - Tests: a second run plans nothing (planner and archive), companions found alike by the trash and Reorganize whatever their case, a photo deleted before a Reorganize comes back beside the new names, a Reorganize waits for a busy restore and settles it first. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
eb2395d9b0 |
feat(archive): reorganize existing sequences with folder, file and title templates
Owner review 2, R7 asks for renaming and moving after import, on the web panel and the desktop. This is the engine and the server API both UIs build on. - FrameNaming (Core/Naming) is the one naming context and unique-name rule of a frame: imports, uploads and Reorganize now produce identical names (behaviour of the ingest and the import planner unchanged). - RenamePlanner takes a file template: each step counts its renamed frames, shows the first three and the frames version they were planned at, and lists what keeps its name (photos in place outside originals/, never hashed, missing, unreadable sidecar). Names are given in index order with _2, _3 as filing does; XMP companions follow their photo. - MassRenamer renames a step's files under the same leases after its folder moved, checks the frames version, journals .chronos/rename-files.json and moves files in two phases through temporary names so chains and swaps never meet; then sidecar, index (FrameRepository.RenameFilesAsync, both dialects) and journal. A failure puts every file back; a crash is completed by the next writer or the plan's resume, the index following. Plans a paused or cancelled job holds are left to that job. - JobKind.Move gets MoveJobHandler: it plans again and applies only the confirmed plan (fingerprint and frames versions), with progress and checkpoints per sequence. - POST /api/v1/archive/reorganize: dry run with the plan and its fingerprint, otherwise a 202 move job; validated templates, audited, sequenceChanged reorganized events. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit aae1c3eb18ea932b4a6251c5e2a282b9295a5785) |
||
|
|
4518ffe655 |
fix(archive): settle trash journals under their leases and say why restored photos stayed
Second fix round of owner review 2, phase 3 (engine, server, desktop). - A photo never hashed whose original is missing can be deleted again: it goes into its trash record without a file and without a tombstone (nothing is left to name), stays listed until Empty erases it, and a restore keeps it with the reason "no file". FrameDeleteBlock.Unhashable now blocks only a present original that cannot be read; the API answers it as 409 photo_unreadable naming the photo, and every block has its own code and message. - Deleting a whole sequence first settles an interrupted photo deletion, restore or ingest of it (ReadLocked under its lease), so no journal or half entry travels into the sequence's trash entry; it refuses while a restore into it waits for its busy entry. - FrameTrash.Settle takes the photo entry's lease and leaves the journal for later while the entry is busy (an emptying), so it never races EraseAsync; meanwhile no other restore writes its journal over it and scans do not adopt its files. - The hashes computed for frames that stay (to find a twin of a deleted photo) go into the sidecar and index, and only a frame whose first and last 64 KiB match a deleted photo's is read whole. - A restore into a new sequence rewrites its record after each photo filed, so a crash or a database failure never leaves filed photos listed. - An upload completion no longer has a window before the commit: the ingest checks the sidecar's tombstones under the sequence lease a deletion takes (IngestRequest.RefuseRemoved), unless the upload asked to bring it back. - A restore reports each kept photo with its reason (no longer matches its record, could not be moved back, already in the sequence, had no file); the desktop line and the API message say so in en and it, and the tooltip holds the whole sentence. The desktop tells TrashMismatchException by its type. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 1858f1f450a35fb8383ede8d80ce5f8de9b7ceac) |
||
|
|
66c3662954 |
fix(server): trash and photo-delete API answers, body limit and audit
- frames/delete carries its own request body limit (about 4.8 MB), so the documented 100,000 ids fit; the server's 1 MiB stopped at about 26,900. - Restore tells a damaged or foreign sidecar of the target sequence (409 sidecar_mismatch) from an entry whose files no longer match its record (422 trash_mismatch, now a TrashMismatchException); frames/delete answers sidecar_mismatch instead of 500, and 404 when the sequence left the index between plan and delete, also on the re-plan. - With the archive offline, the trash list and the empty plan answer 503 archive_offline instead of an empty trash; a read-only archive still lists and plans but cannot be emptied. - The empty request is audited as trash_empty_requested: the job checks the plan again and may erase nothing, so the entry no longer claims an erase that has not happened. - API tests for these paths, a named subset emptied, sequence-entry restore and sequence_in_library, photos restored into a new sequence, viewer 403 on bulk routes and admin deletes of another user's photos. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit fa35831d55c44746f7f76e0cff262ed6aecf8e72) |