core/dev.gmitch215.drift.case

Package-level declarations

Types

Where archive files live: whole files as bytes, since a tar is not text.

Builds the case directory for one comparison from the engine's full structured results. Nothing here depends on time, paths or the host, so the bytes are the same on every target. The results/ file is empty: outcomes of experiments are ingested later (6d3).

CaseFile

class CaseFile(files: Map<String, String>)

A case directory in memory: relative path to canonical text, sorted by path. Every file is generated output, so the same inputs give the same bytes. The archive writer and verify of 6d4 start from archiveEntries and check; they add certificate.json, confirmed/, reproduce/ and report.html beside these files and extend the chain over results/.

CaseFiles

interface CaseFiles

Where case files live: the host reads them and each target supplies its own writer.

CaseProblem

sealed interface CaseProblem

A reason a case directory cannot be read or does not check out; never thrown.

CaseRead

sealed interface CaseRead

CaseStore

object CaseStore

Writes and reads a CaseFile under a directory; a bad file is a typed result, not a throw.

CaseWrite

sealed interface CaseWrite

Chain

object Chain

The hash chain over observation records. An entry's hash covers the previous hash and the canonical content (the record without its prev and hash fields).

ChainBroken

data class ChainBroken(val path: String, val index: Int, val detail: String) : CaseProblem

The first observation whose link to the chain does not hold; ChainBroken.index counts from 0.

Detail

enum Detail : Enum<Detail>

How much of the structured result to show. The engine and the case files do not know it.

HashMismatch

data class HashMismatch(val path: String, val expected: String, val actual: String) : CaseProblem

MalformedFile

data class MalformedFile(val path: String, val detail: String) : CaseProblem

MemoryArchiveFiles

class MemoryArchiveFiles(val files: MutableMap<String, ByteArray> = mutableMapOf()) : ArchiveFiles

MemoryCaseFiles

class MemoryCaseFiles(val files: MutableMap<String, String> = mutableMapOf()) : CaseFiles

MissingFile

data class MissingFile(val path: String) : CaseProblem

Render

object Render

Plain text for a ranking and a plan, at three levels from the same data. The inputs are the canonical JSON of Ranking and Plan, which is what a case directory holds, so a live result and a case read back render the same. Lines stay within WIDTH columns.

Tar

object Tar

Plain USTAR tar of text files, written the same way on every target: sorted names, mode 0644, uid and gid 0, mtime 0, no compression, two zero blocks at the end. read accepts only archives that write would have produced, so reading and writing back gives the same bytes.

TarBadHeader