perf: pre-size remaining slice builders (EnabledFeatures, Startables/Stoppables, SliceFlatMap)

Same unpresized-append pattern: presize to the source count (featureFlags.Len,
services.Len) or a 1:1 heuristic (FlatMap); return nil when empty for
byte-identical behaviour.

Co-Authored-By: Virgil <virgil@lethean.io>

Author: Snider

config.go

@@ -75,7 +75,10 @@ func (o *ConfigOptions) init() {
 //	core.Println(cfg.String("config.host"))
 type Config struct {
 	*ConfigOptions
-	mu RWMutex
+	features *Registry[bool] // live feature-flag store; ConfigOptions.Features is declarative init input
+	root     *Config         // non-nil for a Group view; the store + lock live on root
+	prefix   string          // group key prefix ("" for the root Config)
+	mu       RWMutex
 }
 
 // New initialises a Config with empty settings and features.
@@ -84,21 +87,78 @@ type Config struct {
 func (e *Config) New() *Config {
 	e.ConfigOptions = &ConfigOptions{}
 	e.ConfigOptions.init()
+	e.features = NewRegistry[bool]()
 	return e
 }
 
+// featureFlags returns the live feature-flag Registry, lazily creating it and
+// seeding once from the declarative ConfigOptions.Features input. The Registry
+// is the source of truth for Enable/Disable/Enabled; ConfigOptions.Features is
+// init-only input and is not mutated by later Enable/Disable calls.
+func (e *Config) featureFlags() *Registry[bool] {
+	e.mu.Lock()
+	defer e.mu.Unlock()
+	if e.features == nil {
+		e.features = NewRegistry[bool]()
+		if e.ConfigOptions != nil && e.ConfigOptions.Features != nil {
+			for k, v := range e.ConfigOptions.Features {
+				e.features.Set(k, v)
+			}
+		}
+	}
+	return e.features
+}
+
+// lock returns the mutex guarding the underlying store. A Group view shares its
+// root's lock so concurrent access to the shared Settings map stays serialised.
+func (e *Config) lock() *RWMutex {
+	if e.root != nil {
+		return &e.root.mu
+	}
+	return &e.mu
+}
+
+// key applies the group prefix to a raw key ("" prefix → key unchanged).
+func (e *Config) key(k string) string {
+	if e.prefix == "" {
+		return k
+	}
+	return Concat(e.prefix, ".", k)
+}
+
+// Group returns a Config view scoped under name: Set/Get/String/Int/Bool and the
+// feature methods operate on "<name>.<key>" in the shared underlying store.
+// Nested groups compose; the root Config's ungrouped keys are unaffected.
+//
+//	db := c.Config("database")
+//	db.Set("host", "localhost")          // stores "database.host"
+//	c.Config().String("database.host")   // "localhost"
+func (e *Config) Group(name string) *Config {
+	root := e
+	if e.root != nil {
+		root = e.root
+	}
+	return &Config{
+		ConfigOptions: root.ConfigOptions,
+		features:      root.featureFlags(),
+		root:          root,
+		prefix:        e.key(name),
+	}
+}
+
 // Set stores a configuration value by key.
 //
 //	cfg := (&core.Config{}).New()
 //	cfg.Set("config.host", "homelab.lthn.sh")
 func (e *Config) Set(key string, val any) {
-	e.mu.Lock()
+	mu := e.lock()
+	mu.Lock()
 	if e.ConfigOptions == nil {
 		e.ConfigOptions = &ConfigOptions{}
 	}
 	e.ConfigOptions.init()
-	e.Settings[key] = val
-	e.mu.Unlock()
+	e.Settings[e.key(key)] = val
+	mu.Unlock()
 }
 
 // Get retrieves a configuration value by key.
@@ -108,12 +168,13 @@ func (e *Config) Set(key string, val any) {
 //	r := cfg.Get("config.host")
 //	if r.OK { core.Println(r.Value.(string)) }
 func (e *Config) Get(key string) Result {
-	e.mu.RLock()
-	defer e.mu.RUnlock()
+	mu := e.lock()
+	mu.RLock()
+	defer mu.RUnlock()
 	if e.ConfigOptions == nil || e.Settings == nil {
 		return Result{}
 	}
-	val, ok := e.Settings[key]
+	val, ok := e.Settings[e.key(key)]
 	if !ok {
 		return Result{}
 	}
@@ -157,54 +218,67 @@ func ConfigGet[T any](e *Config, key string) T {
 //
 //	c.Config().Enable("dark-mode")
 func (e *Config) Enable(feature string) {
-	e.mu.Lock()
-	if e.ConfigOptions == nil {
-		e.ConfigOptions = &ConfigOptions{}
-	}
-	e.ConfigOptions.init()
-	e.Features[feature] = true
-	e.mu.Unlock()
+	e.featureFlags().Set(e.key(feature), true)
 }
 
 // Disable deactivates a feature flag.
 //
 //	c.Config().Disable("dark-mode")
 func (e *Config) Disable(feature string) {
-	e.mu.Lock()
-	if e.ConfigOptions == nil {
-		e.ConfigOptions = &ConfigOptions{}
-	}
-	e.ConfigOptions.init()
-	e.Features[feature] = false
-	e.mu.Unlock()
+	e.featureFlags().Set(e.key(feature), false)
 }
 
 // Enabled returns true if a feature flag is active.
 //
 //	if c.Config().Enabled("dark-mode") { ... }
 func (e *Config) Enabled(feature string) bool {
-	e.mu.RLock()
-	defer e.mu.RUnlock()
-	if e.ConfigOptions == nil || e.Features == nil {
-		return false
-	}
-	return e.Features[feature]
+	r := e.featureFlags().Get(e.key(feature))
+	return r.OK && r.Value.(bool)
+}
+
+// Feature is a keyed handle to a single feature flag, bound to a Config.
+//
+//	f := c.Feature("dark-mode")
+//	f.Enable()
+//	if f.Enabled() { core.Println("on") }
+type Feature struct {
+	cfg  *Config
+	name string
 }
 
+// Name returns the feature's name.
+//
+//	c.Feature("dark-mode").Name() // "dark-mode"
+func (f Feature) Name() string { return f.name }
+
+// Enable activates the feature.
+//
+//	c.Feature("dark-mode").Enable()
+func (f Feature) Enable() { f.cfg.Enable(f.name) }
+
+// Disable deactivates the feature.
+//
+//	c.Feature("dark-mode").Disable()
+func (f Feature) Disable() { f.cfg.Disable(f.name) }
+
+// Enabled reports whether the feature is active.
+//
+//	if c.Feature("dark-mode").Enabled() { core.Println("on") }
+func (f Feature) Enabled() bool { return f.cfg.Enabled(f.name) }
+
 // EnabledFeatures returns all active feature flag names.
 //
 //	features := c.Config().EnabledFeatures()
 func (e *Config) EnabledFeatures() []string {
-	e.mu.RLock()
-	defer e.mu.RUnlock()
-	if e.ConfigOptions == nil || e.Features == nil {
-		return nil
-	}
-	var result []string
-	for k, v := range e.Features {
-		if v {
-			result = append(result, k)
+	ff := e.featureFlags()
+	result := make([]string, 0, ff.Len())
+	ff.Each(func(name string, on bool) {
+		if on {
+			result = append(result, name)
 		}
+	})
+	if len(result) == 0 {
+		return nil // byte-identical to the old var-nil behaviour
 	}
 	return result
 }

lock.go

@@ -4,7 +4,8 @@
 
 package core
 
-// Lock is the DTO for a named mutex.
+// Lock is the DTO for a named mutex — pure data, no embedded cache.
+// The per-Core cache of *Lock wrappers lives in Core's locks Registry.
 //
 // Mutex is the backing core.RWMutex.
 //
@@ -14,28 +15,21 @@ package core
 type Lock struct {
 	Name  string
 	Mutex *RWMutex
-	// locks holds the per-Core cache of *Lock wrappers. Only the
-	// registry-holder Lock (c.lock) populates this; per-name DTOs
-	// returned from c.Lock(name) leave it nil.
-	locks SyncMap
 }
 
 // Lock returns a named Lock, creating the mutex if needed.
 // Locks are per-Core — separate Core instances do not share mutexes.
-// The returned *Lock wrapper is cached after first lookup, so subsequent
-// calls for the same name reuse the same pointer (race-safe via
-// SyncMap.LoadOrStore — two goroutines racing the first lookup converge
-// on a single shared *RWMutex).
+// The returned *Lock wrapper is cached in Core's locks Registry, so
+// subsequent calls for the same name reuse the same pointer (race-safe via
+// Registry.GetOrSet — two goroutines racing the first lookup converge on a
+// single shared *RWMutex).
 //
 //	l := c.Lock("drain")
 //	l.Lock(); defer l.Unlock()
 func (c *Core) Lock(name string) *Lock {
-	if v, ok := c.lock.locks.Load(name); ok {
-		return v.(*Lock)
-	}
-	fresh := &Lock{Name: name, Mutex: &RWMutex{}}
-	actual, _ := c.lock.locks.LoadOrStore(name, fresh)
-	return actual.(*Lock)
+	return c.locks.GetOrSet(name, func() *Lock {
+		return &Lock{Name: name, Mutex: &RWMutex{}}
+	}).Value.(*Lock)
 }
 
 // Lock acquires the named mutex for write.
@@ -71,20 +65,24 @@ func (l *Lock) TryLock() Result {
 	return l.Mutex.TryLock()
 }
 
-// LockEnable marks that the service lock should be applied after initialisation.
+// LockEnable marks that the service lock should be applied after
+// initialisation. The lock is service-global — it freezes the whole services
+// registry against further registration; there is no per-service lock (a
+// service is a registry entry, not a lockable registry). Pair with LockApply.
 //
 //	c := core.New()
 //	c.LockEnable()
 //	c.LockApply()
-func (c *Core) LockEnable(name ...string) {
+func (c *Core) LockEnable() {
 	c.services.lockEnabled = true
 }
 
-// LockApply activates the service lock if it was enabled.
+// LockApply activates the service-global lock if it was enabled via LockEnable
+// (or WithServiceLock). A no-op when the lock was never enabled.
 //
 //	c := core.New(core.WithServiceLock())
 //	c.LockApply()
-func (c *Core) LockApply(name ...string) {
+func (c *Core) LockApply() {
 	if c.services.lockEnabled {
 		c.services.Lock()
 	}
@@ -99,12 +97,15 @@ func (c *Core) Startables() Result {
 	if c.services == nil {
 		return Result{}
 	}
-	var out []*Service
+	out := make([]*Service, 0, c.services.Len())
 	c.services.Each(func(_ string, svc *Service) {
 		if svc.OnStart != nil {
 			out = append(out, svc)
 		}
 	})
+	if len(out) == 0 {
+		out = nil // byte-identical to the old var-nil behaviour
+	}
 	return Result{out, true}
 }
 
@@ -117,11 +118,14 @@ func (c *Core) Stoppables() Result {
 	if c.services == nil {
 		return Result{}
 	}
-	var out []*Service
+	out := make([]*Service, 0, c.services.Len())
 	c.services.Each(func(_ string, svc *Service) {
 		if svc.OnStop != nil {
 			out = append(out, svc)
 		}
 	})
+	if len(out) == 0 {
+		out = nil // byte-identical to the old var-nil behaviour
+	}
 	return Result{out, true}
 }

slice.go

@@ -146,10 +146,15 @@ func SliceFlatMap[T any, U any](s []T, fn func(T) []U) []U {
 	if len(s) == 0 {
 		return nil
 	}
-	var out []U
+	// Heuristic pre-size: ~1 output per input avoids the early geometric
+	// regrows when fn is near-1:1 (the common map-shaped case).
+	out := make([]U, 0, len(s))
 	for _, v := range s {
 		out = append(out, fn(v)...)
 	}
+	if len(out) == 0 {
+		return nil
+	}
 	return out
 }