Add Mutagenesis for `tFile`, `tDirectory`, and `tSemaphore` to the Figtree

[andreimerlescu]

Objective

figs := figtree.Grow()
figs.NewSemaphore("max-sessions", 369, "maximum allowed sessions")
_ := figs.Parse()

*figs.Semaphore("max-sessions").Acquire()

*figs.Semaphore("max-sessions").Release()

figs.StoreSemaphore("max-sessions", 434)
// drains existing, closes existing, creates new 

figs.WithValidator("max-sessions", figtree.AssureSemaphoreLessThan(1))
figs.WithValidator("max-sessions", figtree.AssureSemaphoreGreaterThan(2))
figs.WithValidator("max-sessions", figtree.AssureSemaphoreIs(3))

Additionally, from the ROADMAP.md there are notes for this functionality plus the file and directory functionality.

Updating Existing Files

In types.go the const () table should be updated to add tFile, tDirectory and tSemaphore.

const (
    tString      Mutagenesis = "tString"
    tInt         Mutagenesis = "tInt"
    tInt64       Mutagenesis = "tInt64"
    tFloat64     Mutagenesis = "tFloat64"
    tDuration    Mutagenesis = "tDuration"
    tUnitDuration Mutagenesis = "tUnitDuration"
    tBool        Mutagenesis = "tBool"
    tList        Mutagenesis = "tList"
    tMap         Mutagenesis = "tMap"
    tFile        Mutagenesis = "tFile"
    tDirectory   Mutagenesis = "tDirectory"
    tSemaphore   Mutagenesis = "tSemaphore"
)

type Semaphoric interface {
    // Semaphore returns the live *sema.Semaphore registered under name
    Semaphore(name string) *sema.Semaphore
    // NewSemaphore registers a new Semaphore fig with an initial capacity
    NewSemaphore(name string, capacity int, usage string) Plant
    // SemaphoreCapacity returns the current registered capacity integer
    SemaphoreCapacity(name string) int
}

type Fileable interface {
    File(name string) *string
    NewFile(name, path, usage string) Plant
    StoreFile(name, path string) Plant
    FileContents(name string) ([]byte, error)
    FileHandler(name string) (*os.File, error)
    FileWriteContents(name string, contents []byte) error
}

type Directable interface {
    Directory(name string) *string
    NewDirectory(name, path, usage string) Plant
    StoreDirectory(name, path string) Plant
    DirectoryFlushAll(name string) error
}

type figTree struct {
    // ... existing fields unchanged ...
    semaphores sync.Map // map[string]*sema.Semaphore — live objects separate from capacity values
}

type Flesh interface {
    // ... existing methods unchanged ...
    IsFile() bool
    IsDirectory() bool
    IsSemaphore() bool
    
    ToFile() string       // same as ToString but signals intent
    ToDirectory() string  // same as ToString but signals intent
    ToSemaphore() int     // returns capacity integer
}

type CoreMutations interface {
    Intable
    Intable64
    Floatable
    String
    Flaggable
    Durable
    Listable
    Mappable
    Fileable      // new
    Directable    // new
    Semaphoric    // new
}

assure.go Updates

// AssureFileExists ensures the file at the registered path exists.
var AssureFileExists = func(value interface{}) error {
    v := figFlesh{value, nil}
    if !v.IsFile() {
        return ErrInvalidType{tFile, value}
    }
    return check.File(v.ToString(), file.Options{Exists: true})
}

// AssureFileTouchIfNotExists creates the file if it does not exist.
var AssureFileTouchIfNotExists = func(value interface{}) error {
    v := figFlesh{value, nil}
    if !v.IsFile() {
        return ErrInvalidType{tFile, value}
    }
    return check.File(v.ToString(), file.Options{
        Create: file.Create{
            Kind:     file.IfNotExists,
            OpenFlag: os.O_CREATE | os.O_WRONLY,
            FileMode: 0644,
        },
    })
}

// AssureFileCanBeModified ensures the file at the path is writable.
var AssureFileCanBeModified = func(value interface{}) error {
    v := figFlesh{value, nil}
    if !v.IsFile() {
        return ErrInvalidType{tFile, value}
    }
    return check.File(v.ToString(), file.Options{
        Exists:       true,
        RequireWrite: true,
    })
}

// AssureFileSizeGreaterThan ensures the file size exceeds the given byte count.
var AssureFileSizeGreaterThan = func(size int64) FigValidatorFunc {
    return func(value interface{}) error {
        v := figFlesh{value, nil}
        if !v.IsFile() {
            return ErrInvalidType{tFile, value}
        }
        return check.File(v.ToString(), file.Options{
            Exists:        true,
            IsGreaterThan: size,
        })
    }
}

// AssureFileSizeLessThan ensures the file size is below the given byte count.
var AssureFileSizeLessThan = func(size int64) FigValidatorFunc {
    return func(value interface{}) error {
        v := figFlesh{value, nil}
        if !v.IsFile() {
            return ErrInvalidType{tFile, value}
        }
        return check.File(v.ToString(), file.Options{
            Exists:     true,
            IsLessThan: size,
        })
    }
}

// AssureFileModeIs ensures the file has exactly the given os.FileMode.
var AssureFileModeIs = func(mode os.FileMode) FigValidatorFunc {
    return func(value interface{}) error {
        v := figFlesh{value, nil}
        if !v.IsFile() {
            return ErrInvalidType{tFile, value}
        }
        return check.File(v.ToString(), file.Options{
            Exists:     true,
            IsFileMode: mode,
        })
    }
}

// AssureFileOwnerIs ensures the file is owned by the given user (UID as string).
var AssureFileOwnerIs = func(owner string) FigValidatorFunc {
    return func(value interface{}) error {
        v := figFlesh{value, nil}
        if !v.IsFile() {
            return ErrInvalidType{tFile, value}
        }
        return check.File(v.ToString(), file.Options{
            Exists:       true,
            RequireOwner: owner,
        })
    }
}

// AssureFileGroupIs ensures the file belongs to the given group (GID as string).
var AssureFileGroupIs = func(group string) FigValidatorFunc {
    return func(value interface{}) error {
        v := figFlesh{value, nil}
        if !v.IsFile() {
            return ErrInvalidType{tFile, value}
        }
        return check.File(v.ToString(), file.Options{
            Exists:       true,
            RequireGroup: group,
        })
    }
}

// - directory validators

// AssureDirExists ensures the directory at the registered path exists.
var AssureDirExists = func(value interface{}) error {
    v := figFlesh{value, nil}
    if !v.IsDirectory() {
        return ErrInvalidType{tDirectory, value}
    }
    return check.Directory(v.ToString(), directory.Options{Exists: true})
}

// AssureDirCreateIfNotExists creates the directory if it does not exist.
var AssureDirCreateIfNotExists = func(value interface{}) error {
    v := figFlesh{value, nil}
    if !v.IsDirectory() {
        return ErrInvalidType{tDirectory, value}
    }
    return check.Directory(v.ToString(), directory.Options{
        Create: directory.Create{
            Kind:     directory.IfNotExists,
            FileMode: 0755,
        },
    })
}

// AssureDirIsReadable ensures the directory is readable.
var AssureDirIsReadable = func(value interface{}) error {
    v := figFlesh{value, nil}
    if !v.IsDirectory() {
        return ErrInvalidType{tDirectory, value}
    }
    return check.Directory(v.ToString(), directory.Options{
        Exists:             true,
        MorePermissiveThan: 0444,
    })
}

// AssureDirIsWritable ensures the directory is writable.
var AssureDirIsWritable = func(value interface{}) error {
    v := figFlesh{value, nil}
    if !v.IsDirectory() {
        return ErrInvalidType{tDirectory, value}
    }
    return check.Directory(v.ToString(), directory.Options{
        Exists:       true,
        RequireWrite: true,
    })
}

// AssureDirOwnerIs ensures the directory is owned by the given user (UID as string).
var AssureDirOwnerIs = func(owner string) FigValidatorFunc {
    return func(value interface{}) error {
        v := figFlesh{value, nil}
        if !v.IsDirectory() {
            return ErrInvalidType{tDirectory, value}
        }
        return check.Directory(v.ToString(), directory.Options{
            Exists:       true,
            RequireOwner: owner,
        })
    }
}

// AssureDirGroupIs ensures the directory belongs to the given group (GID as string).
var AssureDirGroupIs = func(group string) FigValidatorFunc {
    return func(value interface{}) error {
        v := figFlesh{value, nil}
        if !v.IsDirectory() {
            return ErrInvalidType{tDirectory, value}
        }
        return check.Directory(v.ToString(), directory.Options{
            Exists:       true,
            RequireGroup: group,
        })
    }
}

// AssureDirChmod ensures the directory has exactly the given os.FileMode.
var AssureDirChmod = func(mode os.FileMode) FigValidatorFunc {
    return func(value interface{}) error {
        v := figFlesh{value, nil}
        if !v.IsDirectory() {
            return ErrInvalidType{tDirectory, value}
        }
        // checkfs directory.Options doesn't have IsFileMode directly,
        // so we bracket it with both MorePermissiveThan and LessPermissiveThan
        return check.Directory(v.ToString(), directory.Options{
            Exists:             true,
            MorePermissiveThan: mode,
            LessPermissiveThan: mode,
        })
    }
}

// AssureDirMorePermissiveThan ensures the directory mode is at least as permissive as mode.
var AssureDirMorePermissiveThan = func(mode os.FileMode) FigValidatorFunc {
    return func(value interface{}) error {
        v := figFlesh{value, nil}
        if !v.IsDirectory() {
            return ErrInvalidType{tDirectory, value}
        }
        return check.Directory(v.ToString(), directory.Options{
            Exists:             true,
            MorePermissiveThan: mode,
        })
    }
}

// AssureDirLessPermissiveThan ensures the directory mode is no more permissive than mode.
var AssureDirLessPermissiveThan = func(mode os.FileMode) FigValidatorFunc {
    return func(value interface{}) error {
        v := figFlesh{value, nil}
        if !v.IsDirectory() {
            return ErrInvalidType{tDirectory, value}
        }
        return check.Directory(v.ToString(), directory.Options{
            Exists:             true,
            LessPermissiveThan: mode,
        })
    }
}

// - semaphore validators

// AssureSemaphoreGreaterThan ensures the registered semaphore capacity exceeds the given value.
var AssureSemaphoreGreaterThan = func(above int) FigValidatorFunc {
    return func(value interface{}) error {
        v := figFlesh{value, nil}
        if !v.IsSemaphore() {
            return ErrInvalidType{tSemaphore, value}
        }
        capacity := v.ToSemaphore()
        if capacity <= above {
            return ErrValue{ErrWayBeAbove, capacity, above}
        }
        return nil
    }
}

// AssureSemaphoreLessThan ensures the registered semaphore capacity is below the given value.
var AssureSemaphoreLessThan = func(below int) FigValidatorFunc {
    return func(value interface{}) error {
        v := figFlesh{value, nil}
        if !v.IsSemaphore() {
            return ErrInvalidType{tSemaphore, value}
        }
        capacity := v.ToSemaphore()
        if capacity >= below {
            return ErrValue{ErrWayBeBelow, capacity, below}
        }
        return nil
    }
}

// AssureSemaphoreIs ensures the registered semaphore capacity is exactly the given value.
var AssureSemaphoreIs = func(exact int) FigValidatorFunc {
    return func(value interface{}) error {
        v := figFlesh{value, nil}
        if !v.IsSemaphore() {
            return ErrInvalidType{tSemaphore, value}
        }
        capacity := v.ToSemaphore()
        if capacity != exact {
            return fmt.Errorf("semaphore capacity must be exactly %d, got %d", exact, capacity)
        }
        return nil
    }
}

conversions.go Updates

// toSemaphore returns an interface{} as an int capacity or returns an error.
// tSemaphore stores its capacity as an int — this is just a typed wrapper
// around toInt to make the call site in figFlesh.ToSemaphore() explicit.
func toSemaphore(value interface{}) (int, error) {
    switch v := value.(type) {
    case *Value:
        return toSemaphore(v.Value)
    case *figFlesh:
        return toSemaphore(v.AsIs())
    default:
        i, err := toInt(value)
        if err != nil {
            return 0, ErrConversion{MutagenesisOf(value), tSemaphore, v}
        }
        return i, nil
    }
}

• toInt needs a tSemaphore path.
  Since tSemaphore stores its capacity as an int underneath, and validators call v.ToSemaphore() which will ultimately need to extract that int, you need the conversion chain to work. But actually ToSemaphore() on figFlesh would just call toInt() internally — and toInt() already handles int, *int, string, *string etc. So no change needed there, it falls through naturally.

• toString needs tFile and tDirectory cases.
  These are just strings underneath, so toString already handles them via the *string and string cases. No change needed.

flesh.go Updates

func (flesh *figFlesh) Is(mutagenesis Mutagenesis) bool {
    switch mutagenesis {
    case tInt:
        return flesh.IsInt()
    case tInt64:
        return flesh.IsInt64()
    case tFloat64:
        return flesh.IsFloat64()
    case tBool:
        return flesh.IsBool()
    case tString:
        return flesh.IsString()
    case tList:
        return flesh.IsList()
    case tMap:
        return flesh.IsMap()
    case tDuration:
        return flesh.IsDuration()
    case tUnitDuration:
        return flesh.IsUnitDuration()
    case tFile:           // new
        return flesh.IsFile()
    case tDirectory:      // new
        return flesh.IsDirectory()
    case tSemaphore:      // new
        return flesh.IsSemaphore()
    default:
        return false
    }
}

func (flesh *figFlesh) IsFile() bool {
    switch f := flesh.Flesh.(type) {
    case *figFlesh:
        return f.IsFile()
    case string:
        return true
    case *string:
        return f != nil
    default:
        return false
    }
}

func (flesh *figFlesh) IsDirectory() bool {
    switch f := flesh.Flesh.(type) {
    case *figFlesh:
        return f.IsDirectory()
    case string:
        return true
    case *string:
        return f != nil
    default:
        return false
    }
}

func (flesh *figFlesh) IsSemaphore() bool {
    switch f := flesh.Flesh.(type) {
    case *figFlesh:
        return f.IsSemaphore()
    case int:
        return true
    case *int:
        return f != nil
    default:
        return false
    }
}

func (flesh *figFlesh) ToSemaphore() int {
    f, e := toSemaphore(flesh.Flesh)
    if e != nil {
        isFlesh, ok := flesh.Flesh.(*figFlesh)
        if ok {
            f, e = toSemaphore(isFlesh.Flesh)
            if e != nil {
                return 0
            }
        }
    }
    return f
}

mutations_new.go Updates

// NewFile registers a new file path property
func (tree *figTree) NewFile(name, path, usage string) Plant {
    tree.mu.Lock()
    defer tree.mu.Unlock()
    name = strings.ToLower(name)
    if _, exists := tree.figs[name]; exists {
        tree.problems = append(tree.problems, fmt.Errorf("name '%s' already exists", name))
        return tree
    }
    tree.activateFlagSet()
    vPtr := &Value{
        Value:      path,
        Mutagensis: tFile,
    }
    tree.values.Store(name, vPtr)
    tree.flagSet.Var(vPtr, name, usage)
    def := &figFruit{
        name:        name,
        usage:       usage,
        Mutagenesis: tFile,
        Mutations:   make([]Mutation, 0),
        Validators:  make([]FigValidatorFunc, 0),
        Callbacks:   make([]Callback, 0),
        Rules:       make([]RuleKind, 0),
    }
    tree.figs[name] = def
    if _, exists := tree.withered[name]; !exists {
        tree.withered[name] = witheredFig{
            name:        name,
            Value:       *vPtr,
            Mutagenesis: tFile,
        }
    }
    return tree
}

// NewDirectory registers a new directory path property
func (tree *figTree) NewDirectory(name, path, usage string) Plant {
    tree.mu.Lock()
    defer tree.mu.Unlock()
    name = strings.ToLower(name)
    if _, exists := tree.figs[name]; exists {
        tree.problems = append(tree.problems, fmt.Errorf("name '%s' already exists", name))
        return tree
    }
    tree.activateFlagSet()
    vPtr := &Value{
        Value:      path,
        Mutagensis: tDirectory,
    }
    tree.values.Store(name, vPtr)
    tree.flagSet.Var(vPtr, name, usage)
    def := &figFruit{
        name:        name,
        usage:       usage,
        Mutagenesis: tDirectory,
        Mutations:   make([]Mutation, 0),
        Validators:  make([]FigValidatorFunc, 0),
        Callbacks:   make([]Callback, 0),
        Rules:       make([]RuleKind, 0),
    }
    tree.figs[name] = def
    if _, exists := tree.withered[name]; !exists {
        tree.withered[name] = witheredFig{
            name:        name,
            Value:       *vPtr,
            Mutagenesis: tDirectory,
        }
    }
    return tree
}

// NewSemaphore registers a new immutable semaphore with a fixed capacity.
// Semaphores are not CLI flags and cannot be changed after registration.
func (tree *figTree) NewSemaphore(name string, capacity int, usage string) Plant {
    tree.mu.Lock()
    defer tree.mu.Unlock()
    name = strings.ToLower(name)
    if _, exists := tree.figs[name]; exists {
        tree.problems = append(tree.problems, fmt.Errorf("name '%s' already exists", name))
        return tree
    }
    // capacity sanity check — sema.New clamps to 1 minimum,
    // but we surface the problem at registration time instead
    if capacity < 1 {
        tree.problems = append(tree.problems, fmt.Errorf(
            "semaphore '%s' capacity must be at least 1, got %d", name, capacity,
        ))
        return tree
    }
    v := &Value{
        Value:      capacity,
        Mutagensis: tSemaphore,
    }
    tree.values.Store(name, v)
    // Note: no flagSet.Var — semaphores are not CLI configurable
    def := &figFruit{
        name:        name,
        usage:       usage,
        Mutagenesis: tSemaphore,
        Mutations:   make([]Mutation, 0),
        Validators:  make([]FigValidatorFunc, 0),
        Callbacks:   make([]Callback, 0),
        Rules:       []RuleKind{RulePreventChange}, // immutable by design
    }
    tree.figs[name] = def
    if _, exists := tree.withered[name]; !exists {
        tree.withered[name] = witheredFig{
            name:        name,
            Value:       *v,
            Mutagenesis: tSemaphore,
        }
    }
    // Create the live semaphore immediately — capacity is validated
    // at Parse()/Load() time via WithValidator, but the object exists now
    tree.semaphores.Store(name, sema.New(capacity))
    return tree
}

// File returns the registered file path
func (tree *figTree) File(name string) *string {
    return tree.String(name) // delegates cleanly — same storage, same pipeline
}

// Directory returns the registered directory path
func (tree *figTree) Directory(name string) *string {
    return tree.String(name) // delegates cleanly — same storage, same pipeline
}

// Semaphore returns the live *sema.Semaphore registered under name.
// Returns nil if the name is not registered or not a tSemaphore fig.
func (tree *figTree) Semaphore(name string) sema.Semaphore {
    tree.mu.RLock()
    defer tree.mu.RUnlock()
    name = strings.ToLower(tree.resolveName(name))
    fruit, ok := tree.figs[name]
    if !ok || fruit == nil || fruit.Mutagenesis != tSemaphore {
        return nil
    }
    err := fruit.runCallbacks(tree, CallbackBeforeRead)
    if err != nil {
        fruit.Error = errors.Join(fruit.Error, err)
        tree.figs[name] = fruit
        return nil
    }
    s, ok := tree.semaphores.Load(name)
    if !ok {
        return nil
    }
    err = fruit.runCallbacks(tree, CallbackAfterRead)
    if err != nil {
        fruit.Error = errors.Join(fruit.Error, err)
        tree.figs[name] = fruit
        return nil
    }
    return s.(sema.Semaphore)
}

// SemaphoreCapacity returns the registered capacity integer for a semaphore fig.
func (tree *figTree) SemaphoreCapacity(name string) int {
    tree.mu.RLock()
    defer tree.mu.RUnlock()
    name = strings.ToLower(tree.resolveName(name))
    fruit, ok := tree.figs[name]
    if !ok || fruit == nil || fruit.Mutagenesis != tSemaphore {
        return 0
    }
    value, err := tree.from(name)
    if err != nil {
        return 0
    }
    i, err := toInt(value.Value)
    if err != nil {
        return 0
    }
    return i
}

Update mutations.go

func (tree *figTree) Store(mut Mutagenesis, name string, value interface{}) Plant {
    tree.mu.Lock()
    defer tree.mu.Unlock()
    name = tree.resolveName(name)
    fruit, ok := tree.figs[name]
    if !ok || fruit == nil {
        return tree
    }

    // tSemaphore is immutable by design — reject all Store attempts explicitly
    if fruit.Mutagenesis == tSemaphore {
        tree.figs[name].Error = errors.Join(
            tree.figs[name].Error,
            fmt.Errorf("semaphore '%s' is immutable and cannot be stored into", name),
        )
        return tree
    }

    // ... rest of Store unchanged

Update persist() method

persist needs two new cases — tFile and tDirectory both delegate to the tString case since storage is identical. Adding them explicitly prevents them from falling through to default and silently returning false:

case tFile:
    // tFile stores a path string — identical pipeline to tString
    old, err := toString(flesh)
    if err != nil {
        tree.figs[name].Error = errors.Join(tree.figs[name].Error, err)
        return false, flesh, value
    }
    current, err := toString(value)
    if err != nil {
        tree.figs[name].Error = errors.Join(tree.figs[name].Error, err)
        return false, old, value
    }
    valueAny, ok := tree.values.Load(name)
    if !ok {
        return false, flesh, value
    }
    v, ok := valueAny.(*Value)
    if !ok {
        return false, flesh, value
    }
    err = v.Assign(current)
    if err != nil {
        tree.figs[name].Error = errors.Join(tree.figs[name].Error, err)
        return false, old, value
    }
    tree.values.Store(name, v)
    tree.figs[name] = fruit
    return !strings.EqualFold(old, current), old, current

case tDirectory:
    // tDirectory stores a path string — identical pipeline to tString
    old, err := toString(flesh)
    if err != nil {
        tree.figs[name].Error = errors.Join(tree.figs[name].Error, err)
        return false, flesh, value
    }
    current, err := toString(value)
    if err != nil {
        tree.figs[name].Error = errors.Join(tree.figs[name].Error, err)
        return false, old, value
    }
    valueAny, ok := tree.values.Load(name)
    if !ok {
        return false, flesh, value
    }
    v, ok := valueAny.(*Value)
    if !ok {
        return false, flesh, value
    }
    err = v.Assign(current)
    if err != nil {
        tree.figs[name].Error = errors.Join(tree.figs[name].Error, err)
        return false, old, value
    }
    tree.values.Store(name, v)
    tree.figs[name] = fruit
    return !strings.EqualFold(old, current), old, current

// tSemaphore never reaches persist — blocked in Store() above

validators.go Updates

func (tree *figTree) validateAll() error {
    tree.mu.RLock()
    defer tree.mu.RUnlock()
    err := tree.runCallbacks(CallbackBeforeVerify)
    if err != nil {
        return err
    }
    for name, fruit := range tree.figs {
        if fruit.Error != nil {
            return fruit.Error
        }
        if fruit.HasRule(RuleNoValidations) {
            continue
        }
        for _, validator := range fruit.Validators {
            if fruit != nil && validator != nil {
                var val interface{}
                _value := tree.useValue(tree.from(name))
                if _value == nil {
                    fmt.Printf("skipping invalid fig '%s'\n", name)
                    continue
                }
                switch v := _value.Value.(type) {
                case int:
                    val = v
                case *int:
                    val = *v
                case int64:
                    val = v
                case *int64:
                    val = *v
                case float64:
                    val = v
                case *float64:
                    val = *v
                case string:
                    val = v
                case *string:
                    val = *v
                case bool:
                    val = v
                case *bool:
                    val = *v
                case time.Duration:
                    val = v
                case *time.Duration:
                    val = *v
                case []string:
                    val = v
                case *[]string:
                    val = *v
                case map[string]string:
                    val = v
                case *map[string]string:
                    val = *v
                case ListFlag:
                    val = v.values
                case *ListFlag:
                    val = v.values
                case MapFlag:
                    val = v.values
                case *MapFlag:
                    val = v.values
                case Value:
                    val = v.Value
                case *Value:
                    val = v.Value
                default:
                    log.Printf("unknown fig type: %T for %v\n", v, v)
                }
                if val == nil {
                    log.Printf("val is nil for %s", name)
                }

                // Wrap val in mutagenesis context so assure funcs
                // can distinguish tFile/tDirectory from tString
                wrappedVal := &typedValue{
                    mutagenesis: fruit.Mutagenesis,
                    value:       val,
                }

                if err := validator(wrappedVal); err != nil {
                    return fmt.Errorf("validation failed for %s: %v", name, err)
                }
            }
        }
    }
    for _, fruit := range tree.figs {
        if fruit.Error != nil {
            return fruit.Error
        }
    }
    return tree.runCallbacks(CallbackAfterVerify)
}

flesh.go

func (flesh *figFlesh) IsFile() bool {
    if flesh.mutagenesis == tFile {
        return true
    }
    // fallback for direct construction without mutagenesis context
    switch f := flesh.Flesh.(type) {
    case *figFlesh:
        return f.IsFile()
    case string:
        return true
    case *string:
        return f != nil
    default:
        return false
    }
}

func (flesh *figFlesh) IsDirectory() bool {
    if flesh.mutagenesis == tDirectory {
        return true
    }
    switch f := flesh.Flesh.(type) {
    case *figFlesh:
        return f.IsDirectory()
    case string:
        return true
    case *string:
        return f != nil
    default:
        return false
    }
}

func (flesh *figFlesh) IsSemaphore() bool {
    if flesh.mutagenesis == tSemaphore {
        return true
    }
    switch f := flesh.Flesh.(type) {
    case *figFlesh:
        return f.IsSemaphore()
    case int:
        return true
    case *int:
        return f != nil
    default:
        return false
    }
}

func (flesh *figFlesh) IsString() bool {
    // if mutagenesis context is set, only match tString
    if flesh.mutagenesis != "" && flesh.mutagenesis != tString {
        return false
    }
    switch f := flesh.Flesh.(type) {
    case *figFlesh:
        return f.IsString()
    case string:
        return true
    case *string:
        return f != nil
    default:
        return false
    }
}

validators.go updates

func (tree *figTree) WithValidator(name string, validator func(interface{}) error) Plant {
    tree.mu.Lock()
    defer tree.mu.Unlock()
    name = tree.resolveName(name)
    fig, ok := tree.figs[name]
    if !ok {
        tree.problems = append(tree.problems,
            fmt.Errorf("WithValidator: fig '%s' not registered", name))
        return tree
    }
    if fig.HasRule(RuleNoValidations) {
        return tree
    }

    // tSemaphore validators must not be registered against non-semaphore figs
    // and vice versa — catch obvious mismatches at registration time
    // This is a best-effort check; we can't introspect the validator func's
    // intended type without running it, so we rely on naming conventions
    // (AssureFile*, AssureDir*, AssureSemaphore*) being used correctly.
    // The mutagenesis field on figFlesh during validateAll is the real guard.

    if fig.Validators == nil {
        fig.Validators = make([]FigValidatorFunc, 0)
    }
    fig.Validators = append(fig.Validators, validator)
    tree.figs[name] = fig
    return tree
}

// makeFileValidator creates a validator for tFile path checks.
func makeFileValidator(check func(string) bool, errFormat string) FigValidatorFunc {
    return func(value interface{}) error {
        v := figFlesh{Flesh: value}
        if !v.IsFile() {
            return ErrInvalidType{tFile, value}
        }
        s := v.ToString()
        if !check(s) {
            return fmt.Errorf(errFormat, s)
        }
        return nil
    }
}

// makeDirectoryValidator creates a validator for tDirectory path checks.
func makeDirectoryValidator(check func(string) bool, errFormat string) FigValidatorFunc {
    return func(value interface{}) error {
        v := figFlesh{Flesh: value}
        if !v.IsDirectory() {
            return ErrInvalidType{tDirectory, value}
        }
        s := v.ToString()
        if !check(s) {
            return fmt.Errorf(errFormat, s)
        }
        return nil
    }
}

// makeSemaphoreValidator creates a validator for tSemaphore capacity checks.
func makeSemaphoreValidator(check func(int) bool, errFormat string) FigValidatorFunc {
    return func(value interface{}) error {
        v := figFlesh{Flesh: value}
        if !v.IsSemaphore() {
            return ErrInvalidType{tSemaphore, value}
        }
        i := v.ToSemaphore()
        if !check(i) {
            return fmt.Errorf(errFormat, i)
        }
        return nil
    }
}

rules.go updates

const (
    RuleUndefined                 RuleKind = iota
    RulePreventChange             RuleKind = iota
    RulePanicOnChange             RuleKind = iota
    RuleNoValidations             RuleKind = iota
    RuleNoCallbacks               RuleKind = iota
    RuleCondemnedFromResurrection RuleKind = iota
    RuleNoMaps                    RuleKind = iota
    RuleNoLists                   RuleKind = iota
    RuleNoFlags                   RuleKind = iota
    RuleNoEnv                     RuleKind = iota
    RuleNoFiles                   RuleKind = iota // blocks NewFile, StoreFile, File from being called on the Tree
    RuleNoDirectories             RuleKind = iota // blocks NewDirectory, StoreDirectory, Directory from being called on the Tree
)

mutations_new.go updates

func (tree *figTree) NewFile(name, path, usage string) Plant {
    tree.mu.Lock()
    defer tree.mu.Unlock()
    if tree.HasRule(RuleNoFiles) {
        return tree
    }
    // ... rest unchanged
}

func (tree *figTree) NewDirectory(name, path, usage string) Plant {
    tree.mu.Lock()
    defer tree.mu.Unlock()
    if tree.HasRule(RuleNoDirectories) {
        return tree
    }
    // ... rest unchanged
}

func (tree *figTree) WithRule(name string, rule RuleKind) Plant {
    tree.mu.Lock()
    defer tree.mu.Unlock()
    name = tree.resolveName(name)
    fruit, exists := tree.figs[name]
    if !exists || fruit == nil {
        return tree
    }

    // tSemaphore figs have RulePreventChange baked in at registration.
    // Any attempt to add RuleNoValidations is also blocked — validators
    // are the only mechanism to enforce capacity constraints at Parse time,
    // and silently disabling them on an immutable type would be confusing.
    if fruit.Mutagenesis == tSemaphore {
        switch rule {
        case RuleNoValidations, RuleNoCallbacks:
            // these are permissible — callbacks are fine to suppress
            // validations are debatable but we allow the caller to decide
        default:
            // for anything that would affect mutability, record a problem
            // rather than silently accepting it
            if rule == RulePreventChange || rule == RulePanicOnChange {
                tree.problems = append(tree.problems, fmt.Errorf(
                    "WithRule: '%s' is redundant on semaphore '%s' — already immutable",
                    rule, name,
                ))
                return tree
            }
        }
    }

    fruit.Rules = append(fruit.Rules, rule)
    tree.figs[name] = fruit
    return tree
}

func (r RuleKind) String() string {
    switch r {
    case RuleUndefined:
        return "RuleUndefined"
    case RulePreventChange:
        return "RulePreventChange"
    case RulePanicOnChange:
        return "RulePanicOnChange"
    case RuleNoValidations:
        return "RuleNoValidations"
    case RuleNoCallbacks:
        return "RuleNoCallbacks"
    case RuleCondemnedFromResurrection:
        return "RuleCondemnedFromResurrection"
    case RuleNoMaps:
        return "RuleNoMaps"
    case RuleNoLists:
        return "RuleNoLists"
    case RuleNoFlags:
        return "RuleNoFlags"
    case RuleNoEnv:
        return "RuleNoEnv"
    case RuleNoFiles:
        return "RuleNoFiles"
    case RuleNoDirectories:
        return "RuleNoDirectories"
    default:
        return fmt.Sprintf("RuleKind(%d)", int(r))
    }
}

fruit.go updates

func (v *Value) Set(in string) error {
    switch v.Mutagensis {
    case tString:
        v.Value = in

    case tFile:
        // path stored as string — identical to tString
        v.Value = in

    case tDirectory:
        // path stored as string — identical to tString
        v.Value = in

    case tSemaphore:
        // semaphores are immutable — Set() must never succeed
        // This guards against the flag package or file reload
        // attempting to overwrite the capacity via the Value interface
        v.Err = fmt.Errorf("semaphore capacity is immutable and cannot be set via string")
        return v.Err

    case tBool:
        // ... existing unchanged

}

func (v *Value) Flesh() Flesh {
    return &figFlesh{
        Flesh:       v.Value,
        mutagenesis: v.Mutagensis,
    }
}

func (v *Value) String() string {
    return (&figFlesh{
        Flesh:       v.Value,
        mutagenesis: v.Mutagensis,
    }).ToString()
}

[andreimerlescu]

Looking at everything documented so far, here’s what’s missing or incomplete:

types.go gaps
semaphoreState was proposed but never used anywhere — with immutable semaphores it’s dead code and should be dropped entirely. The figTree struct needs the semaphores sync.Map field added but that addition was only shown in prose, never in the actual struct definition. The Flesh interface is missing ToFile() and ToDirectory() method signatures even though they were discussed. The figFlesh struct itself needs the mutagenesis Mutagenesis field added — this was discussed in validators but never shown as a struct change.

flesh.go gaps
ToFile() and ToDirectory() methods were declared in the interface but never implemented. They’re trivial:

func (flesh *figFlesh) ToFile() string {
    return flesh.ToString()
}

func (flesh *figFlesh) ToDirectory() string {
    return flesh.ToString()
}

The Is() method switch was updated but the existing IsString(), IsInt(), IsBool() etc. need the same mutagenesis context guard that IsString() got — otherwise IsInt() returns true for a tSemaphore fig since both store int underneath. Specifically IsInt() needs:

func (flesh *figFlesh) IsInt() bool {
    if flesh.mutagenesis != "" && flesh.mutagenesis != tInt {
        return false
    }
    // ... existing cases
}

Same pattern needed for IsInt64, IsFloat64, IsBool, IsDuration, IsUnitDuration, IsList, IsMap.

assure.go gaps
The validator constructors use figFlesh{value, nil} throughout but figFlesh now has three fields — Flesh, Error, and mutagenesis. Every construction in assure.go needs updating to named fields:

// wrong — positional, breaks with new field
v := figFlesh{value, nil}

// correct
v := figFlesh{Flesh: value}

This affects all 36 existing validators plus the new ones. It’s a compilation blocker.

validators.go gaps
The wrappedVal approach using &typedValue{mutagenesis: ..., value: val} references a typedValue struct that was never defined anywhere. The correct approach discussed was passing figFlesh{Flesh: val, mutagenesis: fruit.Mutagenesis} directly — but the document still shows the typedValue reference. This needs resolving to either define typedValue or replace all references with figFlesh construction. Given everything else uses figFlesh, the right answer is:

wrappedVal := figFlesh{
    Flesh:       val,
    mutagenesis: fruit.Mutagenesis,
}
if err := validator(wrappedVal); err != nil {
    return fmt.Errorf("validation failed for %s: %v", name, err)
}

mutations.go gaps
MutagenesisOf() is called in Store() to check type compatibility. It needs cases for tFile, tDirectory, and tSemaphore — otherwise a string path value passed to StoreFile would be identified as tString and the type mismatch guard would reject it. That function isn’t shown anywhere in the documents but must exist somewhere and needs updating.
Also StoreFile and StoreDirectory convenience methods were defined in the Fileable interface but never implemented:

func (tree *figTree) StoreFile(name, path string) Plant {
    return tree.Store(tFile, name, path)
}

func (tree *figTree) StoreDirectory(name, path string) Plant {
    return tree.Store(tDirectory, name, path)
}

mutations_new.go gaps
FileContents, FileHandler, FileWriteContents, and DirectoryFlushAll are all declared in the Fileable and Directable interfaces but have zero implementation shown anywhere. These are non-trivial — FileHandler opens a live *os.File and the caller is responsible for closing it, which needs documentation. DirectoryFlushAll calls os.RemoveAll on the stored path which is destructive and needs a deliberate confirmation mechanism or at minimum a clear error if the path doesn’t exist. Minimal implementations:

func (tree *figTree) FileContents(name string) ([]byte, error) {
    path := tree.File(name)
    if path == nil {
        return nil, fmt.Errorf("fig '%s' not found", name)
    }
    return os.ReadFile(*path)
}

func (tree *figTree) FileHandler(name string) (*os.File, error) {
    path := tree.File(name)
    if path == nil {
        return nil, fmt.Errorf("fig '%s' not found", name)
    }
    return os.Open(*path)
}

func (tree *figTree) FileWriteContents(name string, contents []byte) error {
    path := tree.File(name)
    if path == nil {
        return fmt.Errorf("fig '%s' not found", name)
    }
    return os.WriteFile(*path, contents, 0644)
}

func (tree *figTree) DirectoryFlushAll(name string) error {
    path := tree.Directory(name)
    if path == nil {
        return fmt.Errorf("fig '%s' not found", name)
    }
    return os.RemoveAll(*path)
}

go.mod gap
Neither github.com/andreimerlescu/sema nor github.com/andreimerlescu/checkfs appear in any go.mod changes. Both are required dependencies and need adding before anything compiles.

Testing gap
No test file was proposed for the new types. Given the existing pattern of 317 tests, you’d want at minimum:
• TestNewSemaphore_CapacityRegistered
• TestNewSemaphore_ImmutableViaStore
• TestNewSemaphore_AcquireRelease
• TestNewSemaphore_ValidatorRuns
• TestNewFile_PathRegistered
• TestNewFile_ValidatorExists
• TestNewFile_StoreUpdatesPath
• TestNewDirectory_PathRegistered
• TestNewDirectory_ValidatorExists
• TestIsFile_DoesNotPassAsString
• TestIsDirectory_DoesNotPassAsString
• TestIsSemaphore_DoesNotPassAsInt
The last three are critical regression guards for the mutagenesis context field behavior — they verify that the type boundary enforcement actually works at the validator level.​​​​​​​​​​​​​​​​

[andreimerlescu]

tests.go

package figtree

import (
    "os"
    "path/filepath"
    "sync"
    "testing"
    "time"

    "github.com/stretchr/testify/assert"
    "github.com/stretchr/testify/require"
)

// ============================================================================
// HELPERS
// ============================================================================

func testTempFile(t *testing.T, name, content string) string {
    t.Helper()
    path := filepath.Join(t.TempDir(), name)
    require.NoError(t, os.WriteFile(path, []byte(content), 0644))
    return path
}

func testTempDir(t *testing.T, name string) string {
    t.Helper()
    path := filepath.Join(t.TempDir(), name)
    require.NoError(t, os.MkdirAll(path, 0755))
    return path
}

func testFigs(t *testing.T) Plant {
    t.Helper()
    return With(Options{Germinate: true})
}

func testFigsTracking(t *testing.T) Plant {
    t.Helper()
    return With(Options{Germinate: true, Tracking: true, Harvest: 100})
}

// ============================================================================
// tFILE — REGISTRATION
// ============================================================================

func TestNewFile_RegistersWithCorrectMutagenesis(t *testing.T) {
    path := testTempFile(t, "config.txt", "hello")
    figs := testFigs(t)
    figs.NewFile("logfile", path, "log file path")
    require.NoError(t, figs.Parse())

    tree := figs.(*figTree)
    tree.mu.RLock()
    fruit := tree.figs["logfile"]
    tree.mu.RUnlock()

    assert.Equal(t, tFile, fruit.Mutagenesis)
}

func TestNewFile_PathReturnedByGetter(t *testing.T) {
    path := testTempFile(t, "app.log", "")
    figs := testFigs(t)
    figs.NewFile("logfile", path, "log file path")
    require.NoError(t, figs.Parse())

    result := figs.File("logfile")
    require.NotNil(t, result)
    assert.Equal(t, path, *result)
}

func TestNewFile_DuplicateRegistrationRecordsProblem(t *testing.T) {
    path := testTempFile(t, "app.log", "")
    figs := testFigs(t)
    figs.NewFile("logfile", path, "first")
    figs.NewFile("logfile", path, "second")

    assert.NotEmpty(t, figs.Problems())
}

func TestNewFile_RuleNoFilesBlocksRegistration(t *testing.T) {
    figs := testFigs(t)
    figs.WithTreeRule(RuleNoFiles)
    figs.NewFile("logfile", "/tmp/app.log", "log file path")

    tree := figs.(*figTree)
    tree.mu.RLock()
    _, exists := tree.figs["logfile"]
    tree.mu.RUnlock()

    assert.False(t, exists, "RuleNoFiles should block NewFile registration")
}

// ============================================================================
// tFILE — GETTERS
// ============================================================================

func TestFile_ReturnsNilForUnregisteredKey(t *testing.T) {
    figs := testFigs(t)
    require.NoError(t, figs.Parse())
    assert.Nil(t, figs.File("nonexistent"))
}

func TestFile_ReturnsNilForWrongMutagenesis(t *testing.T) {
    figs := testFigs(t)
    figs.NewString("name", "andrei", "a name")
    require.NoError(t, figs.Parse())

    // String getter works fine
    assert.NotNil(t, figs.String("name"))
    // File getter on a tString fig returns nil — wrong type
    assert.Nil(t, figs.File("name"))
}

// ============================================================================
// tFILE — STORE
// ============================================================================

func TestStoreFile_UpdatesPath(t *testing.T) {
    pathA := testTempFile(t, "a.log", "")
    pathB := testTempFile(t, "b.log", "")
    figs := testFigs(t)
    figs.NewFile("logfile", pathA, "log file path")
    require.NoError(t, figs.Parse())

    figs.StoreFile("logfile", pathB)
    result := figs.File("logfile")
    require.NotNil(t, result)
    assert.Equal(t, pathB, *result)
}

func TestStoreFile_EmitsMutationWhenTracking(t *testing.T) {
    pathA := testTempFile(t, "a.log", "")
    pathB := testTempFile(t, "b.log", "")
    figs := testFigsTracking(t)
    figs.NewFile("logfile", pathA, "log file path")
    require.NoError(t, figs.Parse())

    go figs.StoreFile("logfile", pathB)

    select {
    case m := <-figs.Mutations():
        assert.Equal(t, "logfile", m.Property)
    case <-time.After(time.Second):
        t.Fatal("expected mutation after StoreFile")
    }
}

// ============================================================================
// tFILE — VALIDATORS
// ============================================================================

func TestAssureFileExists_PassesWhenFileExists(t *testing.T) {
    path := testTempFile(t, "exists.txt", "content")
    figs := testFigs(t)
    figs.NewFile("datafile", path, "data file")
    figs.WithValidator("datafile", AssureFileExists)
    assert.NoError(t, figs.Parse())
}

func TestAssureFileExists_FailsWhenFileMissing(t *testing.T) {
    figs := testFigs(t)
    figs.NewFile("datafile", "/tmp/figtree-nonexistent-12345.txt", "data file")
    figs.WithValidator("datafile", AssureFileExists)
    assert.Error(t, figs.Parse())
}

func TestAssureFileTouchIfNotExists_CreatesFile(t *testing.T) {
    path := filepath.Join(t.TempDir(), "new.txt")
    figs := testFigs(t)
    figs.NewFile("newfile", path, "new file")
    figs.WithValidator("newfile", AssureFileTouchIfNotExists)
    require.NoError(t, figs.Parse())

    _, err := os.Stat(path)
    assert.NoError(t, err, "file should have been created by validator")
}

func TestAssureFileCanBeModified_PassesOnWritableFile(t *testing.T) {
    path := testTempFile(t, "writable.txt", "")
    figs := testFigs(t)
    figs.NewFile("wfile", path, "writable file")
    figs.WithValidator("wfile", AssureFileCanBeModified)
    assert.NoError(t, figs.Parse())
}

func TestAssureFileSizeGreaterThan_PassesWhenLargeEnough(t *testing.T) {
    path := testTempFile(t, "big.txt", "hello world this is content")
    figs := testFigs(t)
    figs.NewFile("bigfile", path, "big file")
    figs.WithValidator("bigfile", AssureFileSizeGreaterThan(5))
    assert.NoError(t, figs.Parse())
}

func TestAssureFileSizeGreaterThan_FailsWhenTooSmall(t *testing.T) {
    path := testTempFile(t, "small.txt", "hi")
    figs := testFigs(t)
    figs.NewFile("smallfile", path, "small file")
    figs.WithValidator("smallfile", AssureFileSizeGreaterThan(100))
    assert.Error(t, figs.Parse())
}

func TestAssureFileSizeLessThan_PassesWhenSmallEnough(t *testing.T) {
    path := testTempFile(t, "tiny.txt", "hi")
    figs := testFigs(t)
    figs.NewFile("tinyfile", path, "tiny file")
    figs.WithValidator("tinyfile", AssureFileSizeLessThan(100))
    assert.NoError(t, figs.Parse())
}

func TestAssureFileSizeLessThan_FailsWhenTooLarge(t *testing.T) {
    path := testTempFile(t, "large.txt", "hello world this is a lot of content")
    figs := testFigs(t)
    figs.NewFile("largefile", path, "large file")
    figs.WithValidator("largefile", AssureFileSizeLessThan(5))
    assert.Error(t, figs.Parse())
}

func TestAssureFileModeIs_PassesOnCorrectMode(t *testing.T) {
    path := testTempFile(t, "mode.txt", "")
    require.NoError(t, os.Chmod(path, 0644))
    figs := testFigs(t)
    figs.NewFile("modefile", path, "mode file")
    figs.WithValidator("modefile", AssureFileModeIs(0644))
    assert.NoError(t, figs.Parse())
}

func TestAssureFileModeIs_FailsOnWrongMode(t *testing.T) {
    path := testTempFile(t, "mode.txt", "")
    require.NoError(t, os.Chmod(path, 0600))
    figs := testFigs(t)
    figs.NewFile("modefile", path, "mode file")
    figs.WithValidator("modefile", AssureFileModeIs(0644))
    assert.Error(t, figs.Parse())
}

// ============================================================================
// tFILE — TYPE BOUNDARY
// ============================================================================

func TestIsFile_DoesNotPassAsString(t *testing.T) {
    // A tFile fig must not satisfy tString validators
    path := testTempFile(t, "app.log", "")
    figs := testFigs(t)
    figs.NewFile("logfile", path, "log file path")
    // AssureStringNotEmpty is a tString validator — must fail against tFile
    figs.WithValidator("logfile", AssureStringNotEmpty)
    assert.Error(t, figs.Parse(),
        "tString validator must not pass against a tFile fig")
}

func TestFile_MutagenesisIsDistinctFromString(t *testing.T) {
    path := testTempFile(t, "app.log", "")
    figs := testFigs(t)
    figs.NewFile("logfile", path, "log file path")
    require.NoError(t, figs.Parse())

    assert.Equal(t, tFile, figs.MutagenesisOfFig("logfile"))
    assert.NotEqual(t, tString, figs.MutagenesisOfFig("logfile"))
}

// ============================================================================
// tFILE — CONTENTS AND HANDLER
// ============================================================================

func TestFileContents_ReturnsFileBytes(t *testing.T) {
    content := "hello figtree"
    path := testTempFile(t, "content.txt", content)
    figs := testFigs(t)
    figs.NewFile("datafile", path, "data file")
    require.NoError(t, figs.Parse())

    b, err := figs.FileContents("datafile")
    require.NoError(t, err)
    assert.Equal(t, content, string(b))
}

func TestFileContents_ErrorsOnMissingFile(t *testing.T) {
    figs := testFigs(t)
    figs.NewFile("datafile", "/tmp/figtree-missing-99999.txt", "data file")
    require.NoError(t, figs.Parse())

    _, err := figs.FileContents("datafile")
    assert.Error(t, err)
}

func TestFileHandler_ReturnsOpenFile(t *testing.T) {
    path := testTempFile(t, "handler.txt", "data")
    figs := testFigs(t)
    figs.NewFile("hfile", path, "handler file")
    require.NoError(t, figs.Parse())

    f, err := figs.FileHandler("hfile")
    require.NoError(t, err)
    require.NotNil(t, f)
    defer f.Close()
}

func TestFileWriteContents_WritesToFile(t *testing.T) {
    path := testTempFile(t, "write.txt", "original")
    figs := testFigs(t)
    figs.NewFile("wfile", path, "write file")
    require.NoError(t, figs.Parse())

    err := figs.FileWriteContents("wfile", []byte("updated"))
    require.NoError(t, err)

    b, err := os.ReadFile(path)
    require.NoError(t, err)
    assert.Equal(t, "updated", string(b))
}

func TestFileWriteContents_ErrorsOnUnregisteredKey(t *testing.T) {
    figs := testFigs(t)
    require.NoError(t, figs.Parse())
    err := figs.FileWriteContents("nonexistent", []byte("data"))
    assert.Error(t, err)
}

// ============================================================================
// tDIRECTORY — REGISTRATION
// ============================================================================

func TestNewDirectory_RegistersWithCorrectMutagenesis(t *testing.T) {
    path := testTempDir(t, "logs")
    figs := testFigs(t)
    figs.NewDirectory("logdir", path, "log directory")
    require.NoError(t, figs.Parse())

    tree := figs.(*figTree)
    tree.mu.RLock()
    fruit := tree.figs["logdir"]
    tree.mu.RUnlock()

    assert.Equal(t, tDirectory, fruit.Mutagenesis)
}

func TestNewDirectory_PathReturnedByGetter(t *testing.T) {
    path := testTempDir(t, "data")
    figs := testFigs(t)
    figs.NewDirectory("datadir", path, "data directory")
    require.NoError(t, figs.Parse())

    result := figs.Directory("datadir")
    require.NotNil(t, result)
    assert.Equal(t, path, *result)
}

func TestNewDirectory_DuplicateRegistrationRecordsProblem(t *testing.T) {
    path := testTempDir(t, "logs")
    figs := testFigs(t)
    figs.NewDirectory("logdir", path, "first")
    figs.NewDirectory("logdir", path, "second")
    assert.NotEmpty(t, figs.Problems())
}

func TestNewDirectory_RuleNoDirectoriesBlocksRegistration(t *testing.T) {
    figs := testFigs(t)
    figs.WithTreeRule(RuleNoDirectories)
    figs.NewDirectory("logdir", "/tmp", "log dir")

    tree := figs.(*figTree)
    tree.mu.RLock()
    _, exists := tree.figs["logdir"]
    tree.mu.RUnlock()

    assert.False(t, exists, "RuleNoDirectories should block NewDirectory")
}

// ============================================================================
// tDIRECTORY — STORE
// ============================================================================

func TestStoreDirectory_UpdatesPath(t *testing.T) {
    pathA := testTempDir(t, "dirA")
    pathB := testTempDir(t, "dirB")
    figs := testFigs(t)
    figs.NewDirectory("workdir", pathA, "work directory")
    require.NoError(t, figs.Parse())

    figs.StoreDirectory("workdir", pathB)
    result := figs.Directory("workdir")
    require.NotNil(t, result)
    assert.Equal(t, pathB, *result)
}

func TestStoreDirectory_EmitsMutationWhenTracking(t *testing.T) {
    pathA := testTempDir(t, "dirA")
    pathB := testTempDir(t, "dirB")
    figs := testFigsTracking(t)
    figs.NewDirectory("workdir", pathA, "work directory")
    require.NoError(t, figs.Parse())

    go figs.StoreDirectory("workdir", pathB)

    select {
    case m := <-figs.Mutations():
        assert.Equal(t, "workdir", m.Property)
    case <-time.After(time.Second):
        t.Fatal("expected mutation after StoreDirectory")
    }
}

// ============================================================================
// tDIRECTORY — VALIDATORS
// ============================================================================

func TestAssureDirExists_PassesWhenDirExists(t *testing.T) {
    path := testTempDir(t, "existing")
    figs := testFigs(t)
    figs.NewDirectory("datadir", path, "data dir")
    figs.WithValidator("datadir", AssureDirExists)
    assert.NoError(t, figs.Parse())
}

func TestAssureDirExists_FailsWhenDirMissing(t *testing.T) {
    figs := testFigs(t)
    figs.NewDirectory("datadir", "/tmp/figtree-no-such-dir-99999", "data dir")
    figs.WithValidator("datadir", AssureDirExists)
    assert.Error(t, figs.Parse())
}

func TestAssureDirCreateIfNotExists_CreatesDirectory(t *testing.T) {
    path := filepath.Join(t.TempDir(), "newdir")
    figs := testFigs(t)
    figs.NewDirectory("newdir", path, "new directory")
    figs.WithValidator("newdir", AssureDirCreateIfNotExists)
    require.NoError(t, figs.Parse())

    info, err := os.Stat(path)
    require.NoError(t, err)
    assert.True(t, info.IsDir(), "directory should have been created")
}

func TestAssureDirIsWritable_PassesOnWritableDir(t *testing.T) {
    path := testTempDir(t, "writable")
    figs := testFigs(t)
    figs.NewDirectory("wdir", path, "writable dir")
    figs.WithValidator("wdir", AssureDirIsWritable)
    assert.NoError(t, figs.Parse())
}

func TestAssureDirMorePermissiveThan_PassesOnPermissiveDir(t *testing.T) {
    path := testTempDir(t, "permissive")
    require.NoError(t, os.Chmod(path, 0755))
    figs := testFigs(t)
    figs.NewDirectory("pdir", path, "permissive dir")
    figs.WithValidator("pdir", AssureDirMorePermissiveThan(0444))
    assert.NoError(t, figs.Parse())
}

func TestAssureDirLessPermissiveThan_PassesOnRestrictiveDir(t *testing.T) {
    path := testTempDir(t, "restrictive")
    require.NoError(t, os.Chmod(path, 0700))
    figs := testFigs(t)
    figs.NewDirectory("rdir", path, "restrictive dir")
    figs.WithValidator("rdir", AssureDirLessPermissiveThan(0755))
    assert.NoError(t, figs.Parse())
}

// ============================================================================
// tDIRECTORY — TYPE BOUNDARY
// ============================================================================

func TestIsDirectory_DoesNotPassAsString(t *testing.T) {
    path := testTempDir(t, "logs")
    figs := testFigs(t)
    figs.NewDirectory("logdir", path, "log directory")
    figs.WithValidator("logdir", AssureStringNotEmpty)
    assert.Error(t, figs.Parse(),
        "tString validator must not pass against a tDirectory fig")
}

func TestDirectory_MutagenesisIsDistinctFromString(t *testing.T) {
    path := testTempDir(t, "logs")
    figs := testFigs(t)
    figs.NewDirectory("logdir", path, "log directory")
    require.NoError(t, figs.Parse())

    assert.Equal(t, tDirectory, figs.MutagenesisOfFig("logdir"))
    assert.NotEqual(t, tString, figs.MutagenesisOfFig("logdir"))
    assert.NotEqual(t, tFile, figs.MutagenesisOfFig("logdir"))
}

// ============================================================================
// tDIRECTORY — FLUSH
// ============================================================================

func TestDirectoryFlushAll_RemovesContents(t *testing.T) {
    path := testTempDir(t, "flushme")
    // create some contents inside
    require.NoError(t, os.WriteFile(filepath.Join(path, "a.txt"), []byte("a"), 0644))
    require.NoError(t, os.WriteFile(filepath.Join(path, "b.txt"), []byte("b"), 0644))

    figs := testFigs(t)
    figs.NewDirectory("flushdir", path, "flush directory")
    require.NoError(t, figs.Parse())

    err := figs.DirectoryFlushAll("flushdir")
    require.NoError(t, err)

    // path itself should be gone
    _, statErr := os.Stat(path)
    assert.True(t, os.IsNotExist(statErr), "directory should be removed after FlushAll")
}

func TestDirectoryFlushAll_ErrorsOnUnregisteredKey(t *testing.T) {
    figs := testFigs(t)
    require.NoError(t, figs.Parse())
    err := figs.DirectoryFlushAll("nonexistent")
    assert.Error(t, err)
}

// ============================================================================
// tSEMAPHORE — REGISTRATION
// ============================================================================

func TestNewSemaphore_RegistersWithCorrectMutagenesis(t *testing.T) {
    figs := testFigs(t)
    figs.NewSemaphore("max-sessions", 10, "maximum sessions")
    require.NoError(t, figs.Parse())

    tree := figs.(*figTree)
    tree.mu.RLock()
    fruit := tree.figs["max-sessions"]
    tree.mu.RUnlock()

    assert.Equal(t, tSemaphore, fruit.Mutagenesis)
}

func TestNewSemaphore_CapacityStoredCorrectly(t *testing.T) {
    figs := testFigs(t)
    figs.NewSemaphore("max-sessions", 369, "maximum sessions")
    require.NoError(t, figs.Parse())

    assert.Equal(t, 369, figs.SemaphoreCapacity("max-sessions"))
}

func TestNewSemaphore_LiveObjectCreatedImmediately(t *testing.T) {
    figs := testFigs(t)
    figs.NewSemaphore("max-sessions", 10, "maximum sessions")
    // before Parse() — semaphore object should already exist
    s := figs.Semaphore("max-sessions")
    assert.NotNil(t, s)
}

func TestNewSemaphore_DuplicateRegistrationRecordsProblem(t *testing.T) {
    figs := testFigs(t)
    figs.NewSemaphore("max-sessions", 10, "first")
    figs.NewSemaphore("max-sessions", 20, "second")
    assert.NotEmpty(t, figs.Problems())
}

func TestNewSemaphore_ZeroCapacityRecordsProblem(t *testing.T) {
    figs := testFigs(t)
    figs.NewSemaphore("max-sessions", 0, "zero capacity")
    assert.NotEmpty(t, figs.Problems())
}

func TestNewSemaphore_NegativeCapacityRecordsProblem(t *testing.T) {
    figs := testFigs(t)
    figs.NewSemaphore("max-sessions", -1, "negative capacity")
    assert.NotEmpty(t, figs.Problems())
}

func TestNewSemaphore_HasRulePreventChangeAutomatically(t *testing.T) {
    figs := testFigs(t)
    figs.NewSemaphore("max-sessions", 10, "maximum sessions")

    tree := figs.(*figTree)
    tree.mu.RLock()
    fruit := tree.figs["max-sessions"]
    tree.mu.RUnlock()

    assert.True(t, fruit.HasRule(RulePreventChange),
        "semaphore must have RulePreventChange baked in")
}

// ============================================================================
// tSEMAPHORE — IMMUTABILITY
// ============================================================================

func TestNewSemaphore_ImmutableViaStore(t *testing.T) {
    figs := testFigs(t)
    figs.NewSemaphore("max-sessions", 10, "maximum sessions")
    require.NoError(t, figs.Parse())

    // direct Store must be rejected
    figs.Store(tSemaphore, "max-sessions", 999)

    // capacity must be unchanged
    assert.Equal(t, 10, figs.SemaphoreCapacity("max-sessions"))
}

func TestNewSemaphore_ImmutableViaSet(t *testing.T) {
    figs := testFigs(t)
    figs.NewSemaphore("max-sessions", 10, "maximum sessions")
    require.NoError(t, figs.Parse())

    tree := figs.(*figTree)
    valueAny, ok := tree.values.Load("max-sessions")
    require.True(t, ok)
    v := valueAny.(*Value)

    // Set() on a tSemaphore Value must return an error
    err := v.Set("999")
    assert.Error(t, err)
    assert.Equal(t, 10, figs.SemaphoreCapacity("max-sessions"))
}

func TestNewSemaphore_DoesNotEmitMutationOnStoreAttempt(t *testing.T) {
    figs := testFigsTracking(t)
    figs.NewSemaphore("max-sessions", 10, "maximum sessions")
    require.NoError(t, figs.Parse())

    figs.Store(tSemaphore, "max-sessions", 999)

    select {
    case m := <-figs.Mutations():
        t.Fatalf("unexpected mutation received: %+v", m)
    case <-time.After(200 * time.Millisecond):
        // correct — no mutation should arrive
    }
}

func TestNewSemaphore_NotRegisteredAsCLIFlag(t *testing.T) {
    figs := testFigs(t)
    figs.NewSemaphore("max-sessions", 10, "maximum sessions")

    tree := figs.(*figTree)
    f := tree.flagSet.Lookup("max-sessions")
    assert.Nil(t, f, "semaphore must not be registered as a CLI flag")
}

// ============================================================================
// tSEMAPHORE — ACQUIRE / RELEASE
// ============================================================================

func TestSemaphore_AcquireAndRelease(t *testing.T) {
    figs := testFigs(t)
    figs.NewSemaphore("max-sessions", 10, "maximum sessions")
    require.NoError(t, figs.Parse())

    s := figs.Semaphore("max-sessions")
    require.NotNil(t, s)

    s.Acquire()
    assert.Equal(t, 1, s.Len())

    s.Release()
    assert.Equal(t, 0, s.Len())
    assert.True(t, s.IsEmpty())
}

func TestSemaphore_RespectsCapacity(t *testing.T) {
    capacity := 3
    figs := testFigs(t)
    figs.NewSemaphore("workers", capacity, "worker pool")
    require.NoError(t, figs.Parse())

    s := figs.Semaphore("workers")
    require.NotNil(t, s)

    // acquire up to capacity — must not block
    for i := 0; i < capacity; i++ {
        done := make(chan struct{})
        go func() {
            s.Acquire()
            close(done)
        }()
        select {
        case <-done:
        case <-time.After(100 * time.Millisecond):
            t.Fatalf("Acquire %d blocked unexpectedly", i+1)
        }
    }
    assert.Equal(t, capacity, s.Len())

    // acquiring beyond capacity must block
    blocked := make(chan struct{})
    go func() {
        s.Acquire() // this should block
        close(blocked)
    }()
    select {
    case <-blocked:
        t.Fatal("Acquire beyond capacity should have blocked")
    case <-time.After(100 * time.Millisecond):
        // correct — blocked as expected
    }

    // release one — the blocked acquire should now proceed
    s.Release()
    select {
    case <-blocked:
        // correct
    case <-time.After(500 * time.Millisecond):
        t.Fatal("blocked Acquire should have proceeded after Release")
    }
}

func TestSemaphore_ConcurrentAcquireRelease_NoRace(t *testing.T) {
    figs := testFigs(t)
    figs.NewSemaphore("pool", 5, "worker pool")
    require.NoError(t, figs.Parse())

    s := figs.Semaphore("pool")
    require.NotNil(t, s)

    var wg sync.WaitGroup
    for i := 0; i < 20; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            s.Acquire()
            time.Sleep(time.Millisecond)
            s.Release()
        }()
    }
    wg.Wait()
    assert.True(t, s.IsEmpty())
}

func TestSemaphore_ReturnsNilForUnregisteredKey(t *testing.T) {
    figs := testFigs(t)
    require.NoError(t, figs.Parse())
    assert.Nil(t, figs.Semaphore("nonexistent"))
}

func TestSemaphore_ReturnsNilForWrongMutagenesis(t *testing.T) {
    figs := testFigs(t)
    figs.NewInt("workers", 10, "worker count")
    require.NoError(t, figs.Parse())

    // tInt fig must not satisfy Semaphore getter
    assert.Nil(t, figs.Semaphore("workers"))
}

// ============================================================================
// tSEMAPHORE — VALIDATORS
// ============================================================================

func TestAssureSemaphoreGreaterThan_Passes(t *testing.T) {
    figs := testFigs(t)
    figs.NewSemaphore("pool", 10, "pool")
    figs.WithValidator("pool", AssureSemaphoreGreaterThan(5))
    assert.NoError(t, figs.Parse())
}

func TestAssureSemaphoreGreaterThan_Fails(t *testing.T) {
    figs := testFigs(t)
    figs.NewSemaphore("pool", 3, "pool")
    figs.WithValidator("pool", AssureSemaphoreGreaterThan(5))
    assert.Error(t, figs.Parse())
}

func TestAssureSemaphoreLessThan_Passes(t *testing.T) {
    figs := testFigs(t)
    figs.NewSemaphore("pool", 3, "pool")
    figs.WithValidator("pool", AssureSemaphoreLessThan(10))
    assert.NoError(t, figs.Parse())
}

func TestAssureSemaphoreLessThan_Fails(t *testing.T) {
    figs := testFigs(t)
    figs.NewSemaphore("pool", 20, "pool")
    figs.WithValidator("pool", AssureSemaphoreLessThan(10))
    assert.Error(t, figs.Parse())
}

func TestAssureSemaphoreIs_Passes(t *testing.T) {
    figs := testFigs(t)
    figs.NewSemaphore("pool", 369, "pool")
    figs.WithValidator("pool", AssureSemaphoreIs(369))
    assert.NoError(t, figs.Parse())
}

func TestAssureSemaphoreIs_Fails(t *testing.T) {
    figs := testFigs(t)
    figs.NewSemaphore("pool", 10, "pool")
    figs.WithValidator("pool", AssureSemaphoreIs(369))
    assert.Error(t, figs.Parse())
}

// ============================================================================
// tSEMAPHORE — TYPE BOUNDARY
// ============================================================================

func TestIsSemaphore_DoesNotPassAsInt(t *testing.T) {
    figs := testFigs(t)
    figs.NewSemaphore("pool", 10, "pool")
    // AssurePositiveInt is a tInt validator — must fail against tSemaphore
    figs.WithValidator("pool", AssureIntGreaterThan(0))
    assert.Error(t, figs.Parse(),
        "tInt validator must not pass against a tSemaphore fig")
}

func TestSemaphore_MutagenesisIsDistinctFromInt(t *testing.T) {
    figs := testFigs(t)
    figs.NewSemaphore("pool", 10, "pool")
    require.NoError(t, figs.Parse())

    assert.Equal(t, tSemaphore, figs.MutagenesisOfFig("pool"))
    assert.NotEqual(t, tInt, figs.MutagenesisOfFig("pool"))
}

func TestSemaphore_WithRuleRedundantPreventChangeRecordsProblem(t *testing.T) {
    figs := testFigs(t)
    figs.NewSemaphore("pool", 10, "pool")
    figs.WithRule("pool", RulePreventChange)
    assert.NotEmpty(t, figs.Problems(),
        "adding RulePreventChange to a semaphore should record a problem")
}

// ============================================================================
// tSEMAPHORE — CAPACITY GETTER
// ============================================================================

func TestSemaphoreCapacity_ReturnsZeroForUnregisteredKey(t *testing.T) {
    figs := testFigs(t)
    require.NoError(t, figs.Parse())
    assert.Equal(t, 0, figs.SemaphoreCapacity("nonexistent"))
}

func TestSemaphoreCapacity_ReturnsZeroForWrongMutagenesis(t *testing.T) {
    figs := testFigs(t)
    figs.NewInt("workers", 10, "worker count")
    require.NoError(t, figs.Parse())
    assert.Equal(t, 0, figs.SemaphoreCapacity("workers"))
}

// ============================================================================
// CROSS-TYPE ISOLATION
// ============================================================================

func TestCrossType_FileAndDirectoryAndSemaphoreCoexist(t *testing.T) {
    filePath := testTempFile(t, "app.log", "")
    dirPath := testTempDir(t, "data")

    figs := testFigs(t)
    figs.NewFile("logfile", filePath, "log file")
    figs.NewDirectory("datadir", dirPath, "data dir")
    figs.NewSemaphore("pool", 5, "worker pool")

    require.NoError(t, figs.Parse())

    assert.Equal(t, filePath, *figs.File("logfile"))
    assert.Equal(t, dirPath, *figs.Directory("datadir"))
    assert.NotNil(t, figs.Semaphore("pool"))
    assert.Equal(t, 5, figs.SemaphoreCapacity("pool"))

    assert.Equal(t, tFile, figs.MutagenesisOfFig("logfile"))
    assert.Equal(t, tDirectory, figs.MutagenesisOfFig("datadir"))
    assert.Equal(t, tSemaphore, figs.MutagenesisOfFig("pool"))
}

func TestCrossType_StringValidatorFailsOnAllNewTypes(t *testing.T) {
    filePath := testTempFile(t, "app.log", "")
    dirPath := testTempDir(t, "data")

    for _, tc := range []struct {
        name  string
        setup func(Plant)
    }{
        {"file", func(figs Plant) {
            figs.NewFile("target", filePath, "file")
            figs.WithValidator("target", AssureStringNotEmpty)
        }},
        {"directory", func(figs Plant) {
            figs.NewDirectory("target", dirPath, "dir")
            figs.WithValidator("target", AssureStringNotEmpty)
        }},
        {"semaphore", func(figs Plant) {
            figs.NewSemaphore("target", 10, "pool")
            figs.WithValidator("target", AssureStringNotEmpty)
        }},
    } {
        t.Run(tc.name, func(t *testing.T) {
            figs := testFigs(t)
            tc.setup(figs)
            assert.Error(t, figs.Parse(),
                "AssureStringNotEmpty must fail against %s mutagenesis", tc.name)
        })
    }
}

func TestCrossType_IntValidatorFailsOnSemaphore(t *testing.T) {
    figs := testFigs(t)
    figs.NewSemaphore("pool", 10, "pool")
    figs.WithValidator("pool", AssurePositiveInt)
    assert.Error(t, figs.Parse(),
        "AssurePositiveInt must not pass against tSemaphore")
}

[andreimerlescu]

Critical compilation blockers to resolve first

figFlesh struct needs the mutagenesis field before anything else compiles:

type figFlesh struct {
    Flesh       interface{}
    Error       error
    mutagenesis Mutagenesis // unexported — zero value "" means unset
}

All figFlesh positional literals in assure.go must become named fields — this affects all 36 existing validators plus the new ones. Find/replace figFlesh{value, nil} with figFlesh{Flesh: value} across the entire file.

typedValue referenced in validateAll does not exist — replace with direct figFlesh construction:

wrappedVal := figFlesh{
    Flesh:       val,
    mutagenesis: fruit.Mutagenesis,
}
if err := validator(wrappedVal); err != nil {
    return fmt.Errorf("validation failed for %s: %v", name, err)
}

flesh.go — all existing Is* methods need the mutagenesis guard
Not just IsString(). Every type that shares an underlying storage type with a new mutagenesis needs the guard or validators will bleed across type boundaries:

func (flesh *figFlesh) IsInt() bool {
    if flesh.mutagenesis != "" && flesh.mutagenesis != tInt {
        return false
    }
    // ... existing switch unchanged
}

Apply the same pattern to IsInt64, IsFloat64, IsBool, IsDuration, IsUnitDuration, IsList, IsMap. The critical one is IsInt — without it, tSemaphore figs pass IsInt() since both store int, meaning AssurePositiveInt would silently accept a semaphore fig.

ToFile() and ToDirectory() must be implemented — they’re in the Flesh interface but missing from flesh.go:

func (flesh *figFlesh) ToFile() string      { return flesh.ToString() }
func (flesh *figFlesh) ToDirectory() string { return flesh.ToString() }

Flesh() and String() in fruit.go must thread mutagenesis through — this is how the context reaches validators:

func (v *Value) Flesh() Flesh {
    return &figFlesh{Flesh: v.Value, mutagenesis: v.Mutagensis}
}
func (v *Value) String() string {
    return (&figFlesh{Flesh: v.Value, mutagenesis: v.Mutagensis}).ToString()
}

mutations.go — MutagenesisOf() needs updating

Store() calls MutagenesisOf(value) to check type compatibility. Without new cases, passing a string path to StoreFile returns tString and the mismatch guard rejects it. Add tFile, tDirectory, tSemaphore cases wherever MutagenesisOf is defined.

Missing implementations

These are declared in interfaces but have no implementation anywhere in the documented changes:

func (tree *figTree) StoreFile(name, path string) Plant {
    return tree.Store(tFile, name, path)
}

func (tree *figTree) StoreDirectory(name, path string) Plant {
    return tree.Store(tDirectory, name, path)
}

func (tree *figTree) FileContents(name string) ([]byte, error) {
    path := tree.File(name)
    if path == nil {
        return nil, fmt.Errorf("fig '%s' not found", name)
    }
    return os.ReadFile(*path)
}

func (tree *figTree) FileHandler(name string) (*os.File, error) {
    path := tree.File(name)
    if path == nil {
        return nil, fmt.Errorf("fig '%s' not found", name)
    }
    return os.Open(*path)
}

func (tree *figTree) FileWriteContents(name string, contents []byte) error {
    path := tree.File(name)
    if path == nil {
        return fmt.Errorf("fig '%s' not found", name)
    }
    return os.WriteFile(*path, contents, 0644)
}

func (tree *figTree) DirectoryFlushAll(name string) error {
    path := tree.Directory(name)
    if path == nil {
        return fmt.Errorf("fig '%s' not found", name)
    }
    return os.RemoveAll(*path)
}

Note: FileHandler opens for reading only — callers are responsible for Close(). If write access is needed, a separate
FileWriteHandler returning os.OpenFile(..., os.O_WRONLY, ...) may be worth adding.

File() and Directory() getters need mutagenesis guards
Delegating directly to String() means figs.File("some-tString-fig") returns a valid pointer instead of nil. The getter must verify the fig’s mutagenesis before returning:

func (tree *figTree) File(name string) *string {
    tree.mu.RLock()
    name = tree.resolveName(strings.ToLower(name))
    fruit, ok := tree.figs[name]
    tree.mu.RUnlock()
    if !ok || fruit == nil || fruit.Mutagenesis != tFile {
        return nil
    }
    return tree.String(name)
}

func (tree *figTree) Directory(name string) *string {
    tree.mu.RLock()
    name = tree.resolveName(strings.ToLower(name))
    fruit, ok := tree.figs[name]
    tree.mu.RUnlock()
    if !ok || fruit == nil || fruit.Mutagenesis != tDirectory {
        return nil
    }
    return tree.String(name)
}

Without this, TestFile_ReturnsNilForWrongMutagenesis and TestDirectory_MutagenesisIsDistinctFromString will fail.

go.mod — add both dependencies before running tests

go get -u github.com/andreimerlescu/sema
go get -u github.com/andreimerlescu/checkfs

Test file placement

Name the test file mutagenesis_new_test.go to stay consistent with the existing naming pattern. The testTempFile and testTempDir helpers may conflict if watcher_test.go defines similar helpers — check for naming collisions with watcherTestFile before adding.

Test execution order concern

TestSemaphore_RespectsCapacity spawns goroutines that block on Acquire() beyond capacity. The goroutine draining the blocked acquire must release before the test exits — ensure the s.Release() call happens unconditionally even if earlier assertions fail, otherwise the goroutine leaks and the race detector will flag it.​​​​​​​​​​​​​​​​