A desktop sharing the archive that imports into an existing sequence lists the new frames in the sidecar itself and keeps its ThumbsBuilt and ProxiesBuilt. The server scan cleared the flags only when SequenceAdopter.Reconcile found unindexed photos, so it queued no image pass: the new frames, and every frame they renumbered, answered 404 on /thumb and /proxy until a pass was forced. A scan now also clears AnalyzedLight, ThumbsBuilt and ProxiesBuilt when the sidecar's frames version differs from the index row's, decided under the sequence lease, and its follow-ups queue the light analysis and both passes. Writers that change only part of a sequence wrote the whole index row back from a sidecar read under a lease they had already released (decode tiers) or without any (verify stamp): an ingest or a PATCH committed in between was undone, and a row written from a sidecar the index had not synced claimed its frames version, hiding the change from the scan. FrameTiers.RecordAsync and ArchiveVerifier now write the sidecar and only their own columns (SequenceRepository.RecordTiersAsync, RecordVerifiedAsync) under one lease. They and the image passes record the folder's scan stamps only while the index holds the sidecar's frames version (ArchiveIndexer.RecordStampsInStepAsync), so the next scan still sees frames another process added. An image pass decided ThumbsBuilt/ProxiesBuilt from the sidecar it read at its start and set the flag again after a scan had cleared it for photos added meanwhile, so no pass was queued for them. MarkAsync now holds the lease for the sidecar and the index, and sets the flag only while the sidecar lists the photos the pass read at the same indexes; otherwise it clears it. A rebuild deleted every row whose folder was not among those listed when it began, so a sequence that got its first frame or was created by an upload session while it ran lost its row (404 for the Uploader, a second '(2)' sequence for the session). A row is now checked again under its lease, as it and its folder are then, before it goes. Tests: a desktop's ArchiveIngest commit followed by a server scan (Data and Server, /thumb and /proxy answer 200 for every frame); a thumbnail pass with a scan's reconcile in between; tier records and a verify stamp interleaved with a PATCH and with another writer's frames, on SQLite and PostgreSQL; a rebuild during which uploads place and create sequences. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
Titano (development repository)
Time-lapse ecosystem: Titano (Windows desktop client), Titano Server (Linux/Docker and Windows) and Titano Uploader (Windows), sharing one C#/.NET 10 engine with zero third-party packages. This repository is private; users get releases, the Docker image and the Unraid template from the public releases repository.
- Specification:
docs/BRIEF.md· working rules:CLAUDE.md - Architecture and conventions:
docs/ARCHITECTURE.md· decisions:docs/DECISIONS.md· status:docs/STATUS.md· changes:docs/CHANGELOG.md - Visual design:
docs/ui/DESIGN.mdanddocs/ui/mockups/
Build, test, run
Requirements: the .NET SDK pinned in global.json. Windows builds and runs everything; Linux builds everything
(the Windows projects for compile checking) and runs Core, Data, Protocol, Server and Tools.
dotnet build Titano.slnx -c Release
# Tests (one program per area; --filter text|category:name, --junit file, --verbose)
dotnet run --project tests/Titano.Core.Tests -c Release -- --junit out/core.xml
dotnet run --project tests/Titano.Data.Tests -c Release
dotnet run --project tests/Titano.Server.Tests -c Release
dotnet run --project tests/Titano.Tools.Tests -c Release
dotnet run --project tests/Titano.Core.Windows.Tests -c Release # Windows
dotnet run --project tests/Titano.App.Tests -c Release # Windows
# PostgreSQL integration tests (16 or 17); the MD5, cleartext, trust and TLS tests also read TITANO_TEST_PG_MD5,
# _CLEARTEXT, _TRUST, _TLS=1 and _ROOT_CERT (.github/scripts/postgres-ci-setup.sh prepares a server for them)
TITANO_TEST_PG="Host=127.0.0.1;Port=5432;Database=titano_test;Username=titano;Password=…;SslMode=disable" \
dotnet run --project tests/Titano.Data.Tests -c Release
# Performance gates (500,000-photo library, 100,000-frame rebuild; minutes)
TITANO_PERF=1 dotnet run --project tests/Titano.Data.Tests -c Release -- --filter category:perf --verbose
# Checks run by CI
dotnet run --project src/Titano.Tools -- package-guard
dotnet run --project src/Titano.Tools -- i18n check
dotnet run --project src/Titano.Tools -- xaml-lint
dotnet format whitespace Titano.slnx --verify-no-changes
dotnet run --project src/Titano.Tools -- screenshots diff out/screenshots # Windows, after --capture (tests/visual/baselines/README.md)
# CC0 RAW samples for the decoder tests (tests/fixtures/manifest.json explains how to fill in URLs)
dotnet run --project src/Titano.Tools -- fixtures
Run:
dotnet run --project src/Titano.Server # admin panel https://localhost:8443/admin
src/Titano.App/bin/Release/net10.0-windows/Titano.exe [--capture <folder>]
src/Titano.Uploader/bin/Release/net10.0-windows/Titano.Uploader.exe
docker compose -f deploy/docker/docker-compose.yml up -d
The server reads /data/server.json (TITANO_DATA_PATH) and TITANO_* environment variables;
Titano.Server --help lists them. On Linux it needs PostgreSQL; on Windows it defaults to SQLite.
CI
| Workflow | When | What |
|---|---|---|
.github/workflows/ci.yml |
push to main, pull requests |
Windows + Linux build (warnings are errors), all tests, package guard, i18n check, XAML lint, format check, YAML check of workflows and public issue forms, CC0 fixtures (a warning per missing sample), screenshots (--capture, also pushed to the ci-screenshots branch for same-repository PRs) and their pixel diff against tests/visual/baselines, Windows program artifacts, installer test (install, run, upgrade in place, uninstall), PostgreSQL 16/17 integration (SCRAM, MD5, cleartext, trust, TLS), Docker image smoke test |
.github/workflows/docker.yml |
nightly | ghcr.io/<owner>/titano-server:nightly (multi-arch) |
.github/workflows/perf.yml |
weekly, manual | Performance gates on SQLite and PostgreSQL 17; timings in the job summary |
.github/workflows/release.yml |
tag v*, manual re-publish |
The release (below) |
Release process
- Make sure
mainis green anddocs/CHANGELOG.md/docs/STATUS.mdare up to date. - Tag and push:
git tag v0.2.0 && git push origin v0.2.0(pre-releases:v0.2.0-rc.1; they are published as GitHub pre-releases, get no:latestimage and are ignored by the in-app update check). release.ymlthen:- validates the tag, builds with
TitanoVersionfrom the tag and runs every test on Windows; - publishes self-contained single-file programs, signs them when signing secrets exist, packs
Titano-Setup-<v>.exeandTitano-Uploader-Setup-<v>.exe(Titano.Tools pack-installer), signs the setups, zipsTitano-Server-win-x64-<v>.zipandTitano-win-x64-portable-<v>.zip; - writes release notes from the Conventional Commits since the previous tag (
Titano.Tools changelog); a stable tag starts from the previous stable tag, so its notes include what its release candidates brought; - once the Windows tests passed, builds and pushes
ghcr.io/<owner>/titano-server:<v>for amd64 and arm64; - computes
SHA256SUMS, checks the public issue forms, creates (or updates) the GitHub release in the public repository, then moves the image's:latesttag and updates the public repository content (README, EULA,i18n/,SHA256SUMS).:latest, Latest and the content follow the newest stable release: a pre-release, or an older tag published again, only gets its release and its:<v>image. Until the first stable release exists, every tag updates the content.
- validates the tag, builds with
- To publish an existing tag again (for example after adding a secret), run Release manually with the tag.
Secrets and variables
| Name | Kind | Purpose |
|---|---|---|
RELEASES_TOKEN |
secret | Fine-grained PAT with Contents: read and write on the public releases repository. Without it the release is created in this (private) repository, which clients cannot see. |
RELEASES_REPO |
variable (optional) | owner/name of the public repository; default <owner>/titano-releases. release.yml passes it to every build as the TitanoReleasesRepo MSBuild property, so the update check, licence and issue links of the binaries read the repository the release goes to (local builds default to alby96/titano-releases). |
SIGN_PFX_BASE64 |
secret (optional) | Base64 of the Authenticode code-signing certificate (.pfx). Without it builds are unsigned. |
SIGN_PASSWORD |
secret (optional) | Password of that .pfx. |
GITHUB_TOKEN pushes the image to GHCR and moves its :latest tag; no other secret is used.
Bootstrapping the public releases repository
- Create a public repository named
titano-releasesunder the same owner (or setRELEASES_REPO), with a README so it has a default branch. Enable Issues and Private vulnerability reporting (Settings › Security). - Create the fine-grained PAT (repository access: only that repository; permissions: Contents read/write) and store
it as the
RELEASES_TOKENsecret of this repository. - Push a pre-release tag (
v0.1.0-rc.1). The release job copiesdeploy/releases-repo/(README, EULA draft, SECURITY policy, issue forms), the Unraid template and its icon, the compose file and.env.example, the dark screenshots,i18n/and the latestSHA256SUMSinto the public repository after creating the release with the installers, rewriting links to its name and default branch. - After the first image push, open the
titano-serverpackage on GHCR › Package settings and set its visibility to Public (GitHub offers no API for this; the release summary reminds you). - Have the EULA draft (
deploy/releases-repo/EULA.md) reviewed before the first stable release. - In Unraid, add
https://github.com/<owner>/titano-releasesunder Docker › Template repositories to validate the template.
Repository layout
src/ Titano.Core, Core.Windows, Data, Protocol, Server, Ui, App, Uploader, Setup, Tools
tests/ Titano.Testing and one test program per area; fixtures/ (manifest of CC0 samples)
i18n/ <culture>/<Area>.resx string catalogs, GLOSSARY.md
deploy/ docker/ (Dockerfile, compose), unraid/ (template), releases-repo/ (public repository content)
branding/ SVG masters of the icons
docs/ BRIEF, ARCHITECTURE, DECISIONS, STATUS, CHANGELOG, ui/