MerTekTypes

Write the record type in Trident. Each field names a registry type: guid for the work order, timepoint<unix> for the moment of inspection, f64<family=length> for the pad, decimal<scale=2> for labor and duration for the interval. The literal 7.5mm reads at the length type, and the value keeps one coherent amount: 0.0075 metres.

outline brakeReport {
    guid workOrder = 00000000-0000-0000-0000-000000000000
    text bus = ""
    timepoint<unix> checkedAt = 0
    f64<family=length> pad = 0mm
    decimal<scale=2> labor = 0.00
    duration nextDue = 0s
    text? note = null
}

Store it with the same spellings. The MerDB trove declares its columns with the same type names, so the database keeps the work order as a guid and the interval as a duration. A nullable column writes ? and defaults to null. Nothing maps a column type back to a program type, because both read the same registry entry.

# _db/troves/brakeCheck.tri
trove brakeCheck {
    guid? workOrder = null
    text bus = ""
    timepoint<unix> checkedAt = 0
    f64<family=length> pad = 0mm
    decimal<scale=2> labor = 0.00
    duration nextDue = 0s
    index byBus = bus
}

# a/inspect.tri, on the tablet
brakeCheck recordCheck(text bus, f64<family=length> pad, decimal<scale=2> labor) {
    return brakeCheck.insert({ bus = bus, checkedAt = t.clock.now(), pad = pad, labor = labor, nextDue = 30d })
}

Encode it for the office. The Rune bytes carry every field's name and complete type beside its value, so the bytes describe themselves. Listing the fields of the decoded record prints the registry spelling of each one.

text main(text[] argv) {
    brakeReport check = {
        workOrder = 0190f3a2-7c41-7b9e-a2d4-5f8c1e6b9a30
        bus = "Bus 4127"
        checkedAt = 1760000000
        pad = 7.5mm
        labor = 142.50
        nextDue = 30d
        note = null
    }
    chest received = t.chest.decode(t.chest.encode(check))
    chest[] fields = t.chest.fields(received)
    text spelled = ""
    foreach (row in fields) {
        text name = row.name
        text spelling = row.typeSpelling
        spelled = spelled + name + ":" + spelling + " "
    }
    return spelled
}
# bus:text checkedAt:timepoint<domain=unix> labor:decimal<scale=2>
# nextDue:duration note:text? pad:f64<family=length> workOrder:guid

Check it on arrival. The office admits a record only when each field it needs has exactly the type it expects. An older tablet build that sends the work order as a u128 and the pad as a bare f64 is refused before any field is read. Bytes that are not a document at all fail t.chest.check.

text admit(buffer bytes) {
    chest verdict = t.chest.check(bytes)
    bool ok = verdict.ok
    if (!ok) {
        return "not a document"
    }
    chest received = t.chest.decode(bytes)
    expect { guid workOrder, f64<family=length> pad, duration nextDue } = received else {
        return "refused: a field is missing or has another type"
    }
    return "admitted pad " + text(pad)
}
# older build  { u128 workOrder, f64 pad, duration nextDue } -> refused: a field ...
# new build                                                  -> admitted pad 0.0075
# t.buffer.fromText("pad=7.5")                               -> not a document