rakata_generics/

utd.rs

//! UTD (`.utd`) typed generic wrapper.
//!
//! Doors are interactive pathways. Beyond acting as barriers and transitions
//! between areas, they carry lock mechanics, trap configuration, script hooks
//! and visual state (open, destroyed, jammed).
//!
//! ## Scope of this slice
//! - Typed access for all door identity/state/script/link fields.
//! - K1-aligned read defaults for door booleans observed in `LoadDoor`.
//! - Superset-correct: all fields are modeled, no passthrough needed.
//!
//! ## Field Layout (simplified)
//! ```text
//! UTD root struct
//! +-- TemplateResRef / Tag / LocName / Description
//! +-- GenericType / Appearance / OpenState
//! +-- Lock + trap + durability fields
//! +-- Script hooks (OnClosed/OnDamaged/...)
//! +-- Transition fields (LinkedTo/LinkedToFlags/LinkedToModule/TransitionDestin)
//! ```
//!
//! ## The lock and saving-throw fields are declared here, not shared
//!
//! A door and a placeable carry the same seven lock labels and the same three
//! saving throws, and a shared block cannot carry a schema for them: every one
//! of those ten labels is recorded `constructed` on the door against `stamped`
//! on the placeable, so a single entry would state the wrong mechanism for one
//! of them. Across the whole audit that pattern is not confined to the
//! mechanism. A fifth of the paths two views share resolve to a different
//! value depending on the owning type.
//! A shared reader is still right, since the value is the same; the record of
//! how the engine reaches it is not shareable.

use std::io::{Cursor, Read, Write};

use crate::shared::{PORTRAIT_ID_USE_RESREF, SCRIPT_SLOT_SEED, TRAP_TYPE_ABSENT};
use rakata_core::ResRef;
use rakata_formats::gff::get_locstring;
use rakata_formats::schema::FromGff;
use rakata_formats::GENERIC_FILE_TYPE;
use rakata_formats::{
    read_gff, read_gff_from_bytes, write_gff, Gff, GffBinaryError, GffLocalizedString, GffModel,
    GffStruct,
};
use thiserror::Error;

/// Typed UTD model built from/to [`Gff`] data.
#[derive(Debug, Clone, PartialEq, GffModel)]
pub struct Utd {
    /// Door template resref (`TemplateResRef`).
    #[gff(TemplateResRef, unexamined)]
    pub template_resref: ResRef,
    /// Door tag (`Tag`).
    #[gff(Tag, constructed)]
    pub tag: String,
    /// Localized door name (`LocName`).
    #[gff(LocName, stamped)]
    pub name: GffLocalizedString,
    /// Localized door description (`Description`).
    #[gff(Description, stamped)]
    pub description: GffLocalizedString,
    /// Toolset comment (`Comment`). Legacy Odyssey Engine artifact never natively evaluated by the KOTOR engine.
    #[gff(Comment, unexamined)]
    pub comment: String,
    /// Conversation resref (`Conversation`).
    #[gff(Conversation, stamped)]
    pub conversation: ResRef,
    /// Faction identifier (`Faction`).
    #[gff(Faction, constructed)]
    pub faction_id: u32,
    /// Generic door type id (`GenericType`).
    #[gff(GenericType, constructed)]
    pub appearance_id: u8,
    /// Optional appearance table index (`Appearance`). Engine truncates to a single byte; values above 255 wrap to 0 and break door model rendering.
    #[gff(Appearance, unexamined, range_int = (0, 255))]
    pub unused_appearance_id: u32,
    /// Open state (`OpenState`).
    #[gff(OpenState, constructed, omit = audited_constant(575))]
    pub open_state: u8,
    /// Animation state (`AnimationState`). Legacy Odyssey Engine artifact never natively evaluated by the KOTOR engine.
    #[gff(AnimationState, unexamined)]
    pub animation_state: u8,
    /// Door bearing in radians (`Bearing`).
    #[gff(Bearing, constructed, omit = audited_constant(575))]
    pub bearing: f32,
    /// Whether the object can be locked at all (`Lockable`).
    #[gff(Lockable, unexamined)]
    pub lockable: bool,
    /// Whether the object is currently locked (`Locked`).
    #[gff(Locked, constructed)]
    pub locked: bool,
    /// Whether opening requires the named key (`KeyRequired`).
    #[gff(KeyRequired, constructed)]
    pub key_required: bool,
    /// Tag of the key that opens it (`KeyName`).
    #[gff(KeyName, unexamined)]
    pub key_name: String,
    /// Whether the key is consumed on use (`AutoRemoveKey`).
    #[gff(AutoRemoveKey, constructed)]
    pub auto_remove_key: bool,
    /// Security DC to pick the lock (`OpenLockDC`).
    #[gff(OpenLockDC, constructed)]
    pub open_lock_dc: u8,
    /// Security DC to relock it (`CloseLockDC`).
    #[gff(CloseLockDC, constructed)]
    pub close_lock_dc: u8,
    /// Secret door detect DC (`SecretDoorDC`).
    #[gff(SecretDoorDC, constructed, omit = audited_constant(575))]
    pub secret_door_dc: u8,
    /// Open lock difficulty (`OpenLockDiff`, K2-oriented field).
    #[gff(
        OpenLockDiff,
        read_only_dead = "a full-text search of LoadDoor's decompiled body lists exactly seven fields never read anywhere in the function, and this is one of them",
        not_a_constant
    )]
    pub open_lock_diff: u8,
    /// Open lock difficulty modifier (`OpenLockDiffMod`, K2-oriented field).
    #[gff(
        OpenLockDiffMod,
        read_only_dead = "a full-text search of LoadDoor's decompiled body lists exactly seven fields never read anywhere in the function, and this is one of them",
        not_a_constant
    )]
    pub open_lock_diff_mod: i8,
    /// Current hit points (`CurrentHP`). Engine clamps this to `maximum_hp` on template load.
    #[gff(CurrentHP, unexamined)]
    pub current_hp: i16,
    /// Maximum hit points (`HP`).
    #[gff(HP, constructed = 1)]
    pub maximum_hp: i16,
    /// Hardness (`Hardness`).
    #[gff(Hardness, stamped)]
    pub hardness: u8,
    /// Fortitude save (`Fort`).
    #[gff(Fort, constructed)]
    pub fortitude: u8,
    /// Reflex save (`Ref`).
    #[gff(Ref, constructed)]
    pub reflex: u8,
    /// Will save (`Will`).
    #[gff(Will, constructed)]
    pub will: u8,
    /// Plot flag (`Plot`). If `is_static` is true, the engine will force this to true at runtime.
    #[gff(Plot, constructed)]
    pub plot: bool,
    /// Invulnerable flag (`Invulnerable`).
    #[gff(Invulnerable, constructed, omit = audited_constant(575))]
    pub invulnerable: bool,
    /// Min-1HP flag (`Min1HP`).
    #[gff(Min1HP, constructed)]
    pub min1_hp: bool,
    /// Static flag (`Static`).
    #[gff(Static, stamped)]
    pub is_static: bool,
    /// Not-blastable flag (`NotBlastable`, K2-oriented field).
    #[gff(
        NotBlastable,
        read_only_dead = "a full-text search of LoadDoor's decompiled body lists exactly seven fields never read anywhere in the function, and this is one of them",
        not_a_constant
    )]
    pub not_blastable: bool,
    /// Interruptable flag (`Interruptable`). Legacy Odyssey Engine artifact never natively evaluated by the KOTOR engine.
    #[gff(Interruptable, unexamined)]
    pub interruptable: bool,
    /// Portrait ID (`PortraitId`). If `< 0xFFFE`, the engine completely shadows and ignores the string `Portrait` resref field. If `0`, the engine hardcodes the lookup to portrait id `0x22E`.
    #[gff(PortraitId, stamped = PORTRAIT_ID_USE_RESREF)]
    pub portrait_id: u16,
    /// Portrait resref (`Portrait`). Ignored by the engine if `portrait_id` is `< 0xFFFE`.
    #[gff(Portrait, stamped)]
    pub portrait: ResRef,
    /// Palette ID (`PaletteID`). Legacy Odyssey Engine artifact never natively evaluated by the KOTOR engine.
    #[gff(PaletteID, unexamined)]
    pub palette_id: u8,
    /// Trap-detectable flag (`TrapDetectable`).
    #[gff(TrapDetectable, constructed = true)]
    pub trap_detectable: bool,
    /// Trap detect DC (`TrapDetectDC`).
    #[gff(TrapDetectDC, constructed)]
    pub trap_detect_dc: u8,
    /// Trap-disarmable flag (`TrapDisarmable`).
    #[gff(TrapDisarmable, constructed = true)]
    pub trap_disarmable: bool,
    /// Trap disarm DC (`DisarmDC`).
    #[gff(DisarmDC, constructed)]
    pub trap_disarm_dc: u8,
    /// Trap flag (`TrapFlag`).
    #[gff(TrapFlag, constructed)]
    pub trap_flag: u8,
    /// Trap one-shot flag (`TrapOneShot`).
    #[gff(TrapOneShot, constructed = true)]
    pub trap_one_shot: bool,
    /// Trap type (`TrapType`).
    #[gff(TrapType, constructed = TRAP_TYPE_ABSENT)]
    pub trap_type: u8,
    /// On-closed script (`OnClosed`).
    #[gff(OnClosed, constructed = SCRIPT_SLOT_SEED)]
    pub on_closed: ResRef,
    /// On-damaged script (`OnDamaged`).
    #[gff(OnDamaged, constructed = SCRIPT_SLOT_SEED)]
    pub on_damaged: ResRef,
    /// On-death script (`OnDeath`).
    #[gff(OnDeath, constructed = SCRIPT_SLOT_SEED)]
    pub on_death: ResRef,
    /// On-disarm script (`OnDisarm`).
    #[gff(OnDisarm, constructed = SCRIPT_SLOT_SEED)]
    pub on_disarm: ResRef,
    /// On-heartbeat script (`OnHeartbeat`).
    #[gff(OnHeartbeat, constructed = SCRIPT_SLOT_SEED)]
    pub on_heartbeat: ResRef,
    /// On-lock script (`OnLock`).
    #[gff(OnLock, constructed = SCRIPT_SLOT_SEED)]
    pub on_lock: ResRef,
    /// On-melee-attacked script (`OnMeleeAttacked`).
    #[gff(OnMeleeAttacked, constructed = SCRIPT_SLOT_SEED)]
    pub on_melee_attacked: ResRef,
    /// On-open script (`OnOpen`).
    #[gff(OnOpen, constructed = SCRIPT_SLOT_SEED)]
    pub on_open: ResRef,
    /// On-spell-cast-at script (`OnSpellCastAt`).
    #[gff(OnSpellCastAt, constructed = SCRIPT_SLOT_SEED)]
    pub on_spell_cast_at: ResRef,
    /// On-trap-triggered script (`OnTrapTriggered`). If empty, null, or literally named `"default"`, the engine pulls the standard script from `traps.2da` keyed by `trap_type`.
    #[gff(OnTrapTriggered, constructed = SCRIPT_SLOT_SEED)]
    pub on_trap_triggered: ResRef,
    /// On-unlock script (`OnUnlock`).
    #[gff(OnUnlock, constructed = SCRIPT_SLOT_SEED)]
    pub on_unlock: ResRef,
    /// On-user-defined script (`OnUserDefined`).
    #[gff(OnUserDefined, constructed = SCRIPT_SLOT_SEED)]
    pub on_user_defined: ResRef,
    /// On-click script (`OnClick`).
    #[gff(OnClick, constructed = SCRIPT_SLOT_SEED)]
    pub on_click: ResRef,
    /// On-open-failed script (`OnFailToOpen`).
    #[gff(OnFailToOpen, constructed = SCRIPT_SLOT_SEED)]
    pub on_fail_to_open: ResRef,
    /// On-dialog script (`OnDialog`, K2-oriented field).
    #[gff(OnDialog, constructed = SCRIPT_SLOT_SEED, omit = audited_constant(575))]
    pub on_dialog: ResRef,
    /// Linked target flags (`LinkedToFlags`).
    #[gff(
        LinkedToFlags,
        read_only_dead = "LoadDoorExternal overlays this from the save instance immediately after LoadDoor returns, unconditionally whenever the template branch is taken, and a .utd blueprint only ever reaches LoadDoor through that branch",
        unexamined
    )]
    pub linked_to_flags: u8,
    /// Linked target tag (`LinkedTo`).
    #[gff(
        LinkedTo,
        read_only_dead = "LoadDoorExternal overlays this from the save instance immediately after LoadDoor returns, unconditionally whenever the template branch is taken, and a .utd blueprint only ever reaches LoadDoor through that branch",
        unexamined
    )]
    pub linked_to: String,
    /// Linked target module (`LinkedToModule`).
    #[gff(
        LinkedToModule,
        read_only_dead = "LoadDoorExternal overlays this from the save instance immediately after LoadDoor returns, unconditionally whenever the template branch is taken, and a .utd blueprint only ever reaches LoadDoor through that branch",
        unexamined
    )]
    pub linked_to_module: ResRef,
    /// Localized transition destination (`TransitionDestin`).
    ///
    /// The engine truncates the name to the 16-byte GFF label limit. Vanilla
    /// `.utd` blueprints do not carry this field at all; it shows up on the
    /// door and trigger instances inside a module `GIT`.
    #[gff(
        TransitionDestin,
        manual_read,
        read_only_dead = "LoadDoorExternal overlays this from the save instance immediately after LoadDoor returns, unconditionally whenever the template branch is taken, and a .utd blueprint only ever reaches LoadDoor through that branch",
        unexamined
    )]
    pub transition_destination: GffLocalizedString,
    /// Load screen id (`LoadScreenID`).
    #[gff(LoadScreenID, stamped)]
    pub loadscreen_id: u16,
}

impl Utd {
    /// Creates an empty UTD value.
    pub fn new() -> Self {
        Self::default()
    }

    /// Builds typed UTD data from a parsed GFF container.
    ///
    /// # Errors
    ///
    /// Returns [`UtdError::UnsupportedFileType`] for a container that is
    /// neither `UTD ` nor the generic `GFF ` form.
    pub fn from_gff(gff: &Gff) -> Result<Self, UtdError> {
        if gff.file_type != <Utd as FromGff>::MAGIC && gff.file_type != GENERIC_FILE_TYPE {
            return Err(UtdError::UnsupportedFileType(gff.file_type));
        }

        let root = &gff.root;
        let mut utd = Self::read_declared(root);

        // The canonical spelling is the only one a binary GFF can carry, since
        // the other two run past the 16-byte label limit. They reach us from
        // sources that are not bound by it, so the chain is a tolerance rather
        // than an alternative the format offers.
        if let Some(destination) = get_locstring(root, "TransitionDestin")
            .or_else(|| get_locstring(root, "TransitionDestination"))
            .or_else(|| get_locstring(root, "TransDest"))
        {
            utd.transition_destination = destination.clone();
        }

        Ok(utd)
    }

    /// Converts this typed UTD value into a GFF container.
    pub fn to_gff(&self) -> Gff {
        let mut root = GffStruct::new(-1);
        self.write_declared(&mut root);
        Gff::new(*b"UTD ", root)
    }
}

/// Errors produced while reading or writing typed UTD data.
#[derive(Debug, Error)]
pub enum UtdError {
    /// Source file type is not supported by this parser.
    #[error("unsupported UTD file type: {0:?}")]
    UnsupportedFileType([u8; 4]),
    /// Underlying GFF parser/writer error.
    #[error(transparent)]
    Gff(#[from] GffBinaryError),
}

/// Reads typed UTD data from a reader at the current stream position.
///
/// # Errors
///
/// [`UtdError::Gff`] when the stream is not a readable GFF, and
/// [`UtdError::UnsupportedFileType`] when it is a GFF of some other format,
/// carrying the fourcc that was found.
#[cfg_attr(
    feature = "tracing",
    tracing::instrument(level = "debug", skip(reader))
)]
pub fn read_utd<R: Read>(reader: &mut R) -> Result<Utd, UtdError> {
    let gff = read_gff(reader)?;
    Utd::from_gff(&gff)
}

/// Reads typed UTD data directly from bytes.
///
/// # Errors
///
/// [`UtdError::Gff`] when `bytes` are not a readable GFF, and
/// [`UtdError::UnsupportedFileType`] when they are a GFF of some other format,
/// carrying the fourcc that was found.
#[cfg_attr(
    feature = "tracing",
    tracing::instrument(level = "debug", skip(bytes), fields(bytes_len = bytes.len()))
)]
pub fn read_utd_from_bytes(bytes: &[u8]) -> Result<Utd, UtdError> {
    let gff = read_gff_from_bytes(bytes)?;
    Utd::from_gff(&gff)
}

/// Authors the UTD file the typed view describes, into a writer.
///
/// # Errors
///
/// [`UtdError::Gff`] when the writer fails or a value will not encode. The
/// typed view fixes the file type, so `UnsupportedFileType` cannot arise on
/// this side.
#[cfg_attr(
    feature = "tracing",
    tracing::instrument(level = "debug", skip(writer, utd))
)]
pub fn author_utd<W: Write>(writer: &mut W, utd: &Utd) -> Result<(), UtdError> {
    let gff = utd.to_gff();
    write_gff(writer, &gff)?;
    Ok(())
}

/// Authors the UTD file the typed view describes, as bytes.
///
/// # Errors
///
/// [`UtdError::Gff`] when a value will not encode. Writing into a `Vec` has no
/// I/O to fail at.
#[cfg_attr(feature = "tracing", tracing::instrument(level = "debug", skip(utd)))]
pub fn author_utd_to_vec(utd: &Utd) -> Result<Vec<u8>, UtdError> {
    let mut cursor = Cursor::new(Vec::new());
    author_utd(&mut cursor, utd)?;
    Ok(cursor.into_inner())
}

#[cfg(test)]
mod tests {
    #[test]
    fn a_transition_destination_survives_a_round_trip() {
        // Both halves can go dead without failing. `TransitionDestination`
        // exceeds the 16-byte GFF label limit and so never appears, so a
        // reader trying only that spelling finds nothing; a writer whose
        // condition tests the freshly-built output struct rather than the
        // source never fires. Together they drop a door's transition text on
        // read and on write.
        let mut root = GffStruct::new(-1);
        root.push_field(
            gff_label!("TransitionDestin"),
            GffValue::LocalizedString(GffLocalizedString::new(StrRef::from_raw(1234))),
        );

        let utd = Utd::from_gff(&Gff::new(*b"UTD ", root)).expect("parses");
        assert_eq!(
            utd.transition_destination.string_ref,
            StrRef::from_raw(1234)
        );

        let written = utd.to_gff();
        assert!(written.root.field("TransitionDestin").is_some());

        let reparsed = Utd::from_gff(&written).expect("reparses");
        assert_eq!(reparsed.transition_destination, utd.transition_destination);
    }

    use super::*;
    use rakata_core::StrRef;
    use rakata_formats::schema::HasSchema;
    use rakata_formats::{gff_label, GffValue};

    const TEST_UTD: &[u8] = include_bytes!(concat!(
        env!("CARGO_MANIFEST_DIR"),
        "/../../fixtures/test.utd"
    ));

    #[test]
    fn reads_core_utd_fields_from_fixture() {
        let utd = read_utd_from_bytes(TEST_UTD).expect("fixture must parse");

        assert_eq!(utd.tag, "TelosDoor13");
        assert_eq!(utd.template_resref, "door_tel014");
        assert_eq!(utd.name.string_ref.raw(), 123_731);
        assert_eq!(utd.description.string_ref.raw(), -1);
        assert!(utd.auto_remove_key);
        assert_eq!(utd.close_lock_dc, 0);
        assert_eq!(utd.conversation, "convoresref");
        assert!(utd.interruptable);
        assert_eq!(utd.faction_id, 1);
        assert!(utd.plot);
        assert!(utd.not_blastable);
        assert!(utd.min1_hp);
        assert!(utd.key_required);
        assert!(utd.lockable);
        assert!(utd.locked);
        assert_eq!(utd.open_lock_dc, 28);
        assert_eq!(utd.open_lock_diff, 1);
        assert_eq!(utd.open_lock_diff_mod, 1);
        assert_eq!(utd.portrait_id, 0);
        assert!(utd.trap_detectable);
        assert_eq!(utd.trap_detect_dc, 0);
        assert!(utd.trap_disarmable);
        assert_eq!(utd.trap_disarm_dc, 28);
        assert_eq!(utd.trap_flag, 0);
        assert!(utd.trap_one_shot);
        assert_eq!(utd.trap_type, 2);
        assert_eq!(utd.key_name, "keyname");
        assert_eq!(utd.animation_state, 1);
        assert_eq!(utd.unused_appearance_id, 1);
        assert_eq!(utd.maximum_hp, 20);
        assert_eq!(utd.current_hp, 60);
        assert_eq!(utd.hardness, 5);
        assert_eq!(utd.fortitude, 28);
        assert_eq!(utd.reflex, 0);
        assert_eq!(utd.will, 0);
        assert_eq!(utd.on_closed, "onclosed");
        assert_eq!(utd.on_damaged, "ondamaged");
        assert_eq!(utd.on_death, "ondeath");
        assert_eq!(utd.on_disarm, "ondisarm");
        assert_eq!(utd.on_heartbeat, "onheartbeat");
        assert_eq!(utd.on_lock, "onlock");
        assert_eq!(utd.on_melee_attacked, "onmeleeattacked");
        assert_eq!(utd.on_open, "onopen");
        assert_eq!(utd.on_spell_cast_at, "onspellcastat");
        assert_eq!(utd.on_trap_triggered, "ontraptriggered");
        assert_eq!(utd.on_unlock, "onunlock");
        assert_eq!(utd.on_user_defined, "onuserdefined");
        assert_eq!(utd.loadscreen_id, 0);
        assert_eq!(utd.appearance_id, 110);
        assert!(utd.is_static);
        assert_eq!(utd.open_state, 1);
        assert_eq!(utd.on_click, "onclick");
        assert_eq!(utd.on_fail_to_open, "onfailtoopen");
        assert_eq!(utd.comment, "abcdefg");
        assert_eq!(utd.palette_id, 1);
    }

    #[test]
    fn all_fields_survive_typed_roundtrip() {
        let utd = read_utd_from_bytes(TEST_UTD).expect("fixture must parse");
        let bytes = author_utd_to_vec(&utd).expect("write succeeds");
        let reparsed = read_utd_from_bytes(&bytes).expect("reparse succeeds");
        assert_eq!(reparsed, utd);
    }

    #[test]
    fn typed_edits_roundtrip_through_gff_writer() {
        let mut utd = read_utd_from_bytes(TEST_UTD).expect("fixture must parse");
        utd.tag = "TelosDoor13_Rust".into();
        utd.open_state = 2;
        utd.on_open = ResRef::new("rust_on_open").expect("valid resref literal");

        let bytes = author_utd_to_vec(&utd).expect("write succeeds");
        let reparsed = read_utd_from_bytes(&bytes).expect("reparse succeeds");

        assert_eq!(reparsed.tag, "TelosDoor13_Rust");
        assert_eq!(reparsed.open_state, 2);
        assert_eq!(reparsed.on_open, "rust_on_open");
    }

    #[test]
    fn read_utd_from_reader_matches_bytes_path() {
        let mut cursor = Cursor::new(TEST_UTD);
        let from_reader = read_utd(&mut cursor).expect("reader parse succeeds");
        let from_bytes = read_utd_from_bytes(TEST_UTD).expect("bytes parse succeeds");

        assert_eq!(from_reader, from_bytes);
    }

    #[test]
    fn rejects_non_utd_file_type() {
        let mut gff = read_gff_from_bytes(TEST_UTD).expect("fixture must parse");
        gff.file_type = *b"UTC ";

        let err = Utd::from_gff(&gff).expect_err("UTC must be rejected as UTD input");
        assert!(matches!(
            err,
            UtdError::UnsupportedFileType(file_type) if file_type == *b"UTC "
        ));
    }

    #[test]
    fn a_mistyped_transition_destination_reads_as_absent() {
        let mut gff = read_gff_from_bytes(TEST_UTD).expect("fixture must parse");
        gff.root.fields.retain(|field| field.label != "TransDest");
        gff.root
            .push_field(gff_label!("TransDest"), GffValue::UInt32(99));

        let utd = Utd::from_gff(&gff).expect("a mistyped field is not a read failure");

        assert_eq!(utd.transition_destination, GffLocalizedString::default());
    }

    #[test]
    fn write_utd_matches_direct_gff_writer() {
        let utd = read_utd_from_bytes(TEST_UTD).expect("fixture must parse");

        let via_typed = author_utd_to_vec(&utd).expect("typed write succeeds");

        let mut direct = Cursor::new(Vec::new());
        write_gff(&mut direct, &utd.to_gff()).expect("direct write succeeds");

        assert_eq!(via_typed, direct.into_inner());
    }

    #[test]
    fn schema_field_count() {
        assert_eq!(Utd::schema().len(), 64); // 34 core + 7 trap + 15 scripts + 8 toolset
    }

    #[test]
    fn schema_no_duplicate_labels() {
        let mut labels: Vec<&str> = Utd::schema().iter().map(|f| f.label.as_str()).collect();
        labels.sort_unstable();
        let before = labels.len();
        labels.dedup();
        assert_eq!(before, labels.len(), "duplicate labels in UTD schema");
    }
}