Architecture

The system, one component at a time.

Dependencies point one way: capture feeds the archive, everything that reads history reads the archive, and the interface reaches the engine only through a bounded IPC layer. Select a component to see what it does and what it connects to.

Your folders

Capture

Archive

Understanding

Custody

Trust

Boundary

Interface

Watched folders your files

The folders you chose. AFTRIMGE reads them, never keeps its archive inside them, and writes into them only when you restore.

Connects to: Watcher, Restore

Watcher watcher::manager · normalizer · debouncer

One thread per project turns operating-system events into internal signals, pairs renames, applies ignore rules and waits until a file stops changing. A scan on launch catches what changed while AFTRIMGE was closed.

Connects to: Watched folders, Ingest

Ingest analysis::ingest · store::hasher

Decides whether anything actually changed. Streams the settled bytes once, hashing exactly what it writes, and records the version and its event in one transaction.

Connects to: Watcher, Object store, SQLite index, Restore

Object store store::object_store

Content-addressed bytes under objects/ab/cdef…, named by SHA-256. Staged, synced, then published by rename. Identical content is stored once.

Connects to: Ingest, Integrity, Replay, Retention and preservation, Restore, Analysis and archaeology

SQLite index database

Projects, file identities, versions, events, analysis results, preservations and the maintenance log. WAL mode, versioned forward-only migrations, backed up before a format change.

Connects to: Ingest, Replay, Retention and preservation, Integrity, Analysis and archaeology, Restore

Replay replay

The project at any recorded instant: which files existed, under which names, with which content. Timelines, lanes, comparison and export.

Connects to: Object store, SQLite index, IPC

Analysis and archaeology analysis · archaeology · memory · continuity · provenance

Deterministic measurements between images and versions, graded FACT, INFERRED, POSSIBLE or TEMPORAL. Every claim can explain the records and measurements it rests on. No machine learning model.

Connects to: Object store, SQLite index, IPC

Retention and preservation maintenance · ledger · preservation

One definition of what holds content: a retained version, an archived image or a preservation. Retention releases bytes, never history; collection removes only what nothing holds.

Connects to: Object store, SQLite index, IPC

Integrity integrity · integrity::repair

Reads bytes and hashes them: VERIFIED, CORRUPT, MISSING, UNREADABLE or UNVERIFIED. Repairs an object only from a source that itself verifies.

Connects to: Object store, SQLite index, IPC

Restore restore

Plans first, then checks the stored bytes, writes beside the target, checks, swaps in and checks again. Refuses destinations outside the project, including through links. Recorded as new history.

Connects to: Object store, SQLite index, Ingest, Watched folders, IPC

IPC ipc::commands · ipc::protocol · ipc::bounds

The only module that knows Tauri exists. Commands take database identities, and paths only for folders and images you pick in a native dialog; every input is size-bounded. Past bytes reach the interface through the aftrimge:// scheme by snapshot id, never by path.

Connects to: Replay, Analysis and archaeology, Retention and preservation, Integrity, Restore, Interface

Interface React · TypeScript

Formats what the engine says and never adds a grade of its own. It reaches the engine only through IPC, and past file contents only by snapshot id.

Connects to: IPC

Single authorities

Each operational question is answered in one place, so two implementations cannot drift apart: where the archive is, whether it is already open, what format the database is, whether a key may name a file in the project, why an object is kept, whether its bytes are intact, and how large an IPC input may be.

Read further

The engineering record documents every subsystem, invariant and defect found while building it, in 41 sections. How it works follows one saved file through the system.