From 7607b1f8da164a36bddc2c7213fdeec840cbdcb1 Mon Sep 17 00:00:00 2001
From: Andrey Kolkov <a.kolkov@gmail.com>
Date: Wed, 15 Jul 2026 13:54:55 +0300
Subject: [PATCH 1/5] fix: drop per-Subscribe goroutine, eliminate
 close-of-closed-channel race

Replace goroutine+done channel pattern in Subscribe with
context.AfterFunc + atomic.Bool.CompareAndSwap.

Fixes two bugs (issue #6, reported by @AnyCPU):

1. Goroutine leak: each Subscribe spawned a goroutine that blocked
   on select{ctx.Done, done} for the subscription lifetime.
   SubscribeForever (context.Background) parked it forever.
   10k subscriptions = 10k idle goroutines (20-40MB stack waste).

2. Race condition: concurrent cancel() + Unsubscribe() could both
   reach close(done) via non-atomic select-default guard, causing
   panic: close of closed channel.

context.AfterFunc registers cleanup without a goroutine; for
context.Background (Done()==nil) nothing is registered at all.
atomic.Bool.CompareAndSwap makes cleanup idempotent without the
extra heap allocation sync.Once requires.

Signal_Subscribe: 745ns/224B/3allocs -> 192ns/52B/2allocs (3.9x)
Effect_Stop benchmark: OOM -> 552ns (goroutine accumulation gone)
Goroutines per 10k held subs: 10000 -> 0

Closes #6
---
 computed.go                 | 34 +++++----------
 signal.go                   | 41 +++++++-----------
 subscribe_lifecycle_test.go | 84 +++++++++++++++++++++++++++++++++++++
 3 files changed, 111 insertions(+), 48 deletions(-)
 create mode 100644 subscribe_lifecycle_test.go

diff --git a/computed.go b/computed.go
index c7c1ad9..30e552a 100644
--- a/computed.go
+++ b/computed.go
@@ -182,41 +182,29 @@ func (c *computed[T]) Get() T {
 // Note: Unlike regular signals, computed signals only notify after recomputation,
 // not on every dependency change (lazy evaluation).
 func (c *computed[T]) Subscribe(ctx context.Context, fn func(T)) Unsubscribe {
-	// Add subscriber
 	c.mu.Lock()
 	id := c.nextID
 	c.nextID++
 	c.subscribers[id] = fn
 	c.mu.Unlock()
 
-	// Channel for cleanup coordination
-	done := make(chan struct{})
-
-	// Auto-cleanup on context cancellation
-	go func() {
-		select {
-		case <-ctx.Done():
+	var cleaned atomic.Bool
+	remove := func() {
+		if cleaned.CompareAndSwap(false, true) {
 			c.mu.Lock()
 			delete(c.subscribers, id)
 			c.mu.Unlock()
-			close(done)
-		case <-done:
-			// Manual unsubscribe
 		}
-	}()
+	}
 
-	// Return manual unsubscribe
-	return func() {
-		c.mu.Lock()
-		delete(c.subscribers, id)
-		c.mu.Unlock()
+	if ctx.Done() == nil {
+		return remove
+	}
 
-		select {
-		case <-done:
-			// Already closed
-		default:
-			close(done)
-		}
+	stop := context.AfterFunc(ctx, remove)
+	return func() {
+		stop()
+		remove()
 	}
 }
 
diff --git a/signal.go b/signal.go
index 4c427d8..f8ab9aa 100644
--- a/signal.go
+++ b/signal.go
@@ -174,43 +174,34 @@ func (s *signal[T]) Update(fn func(T) T) {
 //	})
 //	defer unsub()  // Cleanup (before context timeout)
 func (s *signal[T]) Subscribe(ctx context.Context, fn func(T)) Unsubscribe {
-	// Add subscriber with unique ID
 	s.mu.Lock()
 	id := s.nextID
 	s.nextID++
 	s.subscribers[id] = fn
 	s.mu.Unlock()
 
-	// Channel to signal cleanup completion
-	done := make(chan struct{})
-
-	// Goroutine for context-based cleanup
-	go func() {
-		select {
-		case <-ctx.Done():
-			// Context canceled - auto cleanup
+	// atomic.Bool.CompareAndSwap makes cleanup idempotent without the
+	// extra heap allocation that sync.Once requires for its struct.
+	var cleaned atomic.Bool
+	remove := func() {
+		if cleaned.CompareAndSwap(false, true) {
 			s.mu.Lock()
 			delete(s.subscribers, id)
 			s.mu.Unlock()
-			close(done)
-		case <-done:
-			// Manual unsubscribe happened
 		}
-	}()
+	}
 
-	// Return manual unsubscribe function
-	return func() {
-		s.mu.Lock()
-		delete(s.subscribers, id)
-		s.mu.Unlock()
+	// ctx.Done() == nil covers context.Background(), context.TODO(),
+	// and any custom never-canceled context — return remove directly
+	// to avoid an extra wrapper closure allocation.
+	if ctx.Done() == nil {
+		return remove
+	}
 
-		// Signal goroutine to stop
-		select {
-		case <-done:
-			// Already closed by context
-		default:
-			close(done)
-		}
+	stop := context.AfterFunc(ctx, remove)
+	return func() {
+		stop()
+		remove()
 	}
 }
 
diff --git a/subscribe_lifecycle_test.go b/subscribe_lifecycle_test.go
new file mode 100644
index 0000000..0169eef
--- /dev/null
+++ b/subscribe_lifecycle_test.go
@@ -0,0 +1,84 @@
+package signals_test
+
+import (
+	"context"
+	"runtime"
+	"sync"
+	"testing"
+
+	"github.com/coregx/signals"
+)
+
+// TestSubscribeForever_10kHeldOpen_NoPerSubscriptionGoroutine is the
+// goroutine-leak regression test.
+//
+// A "subscribe then immediately unsubscribe" loop is not a meaningful
+// regression test here: the pre-fix implementation spawns a goroutine per
+// Subscribe call, but that goroutine correctly exits as soon as
+// Unsubscribe is called manually — sequential subscribe+unsubscribe
+// passes on both the old and new implementation. The actual defect is the
+// goroutine parked for the entire time a subscription is held open
+// (SubscribeForever passes context.Background(), which never cancels, so
+// the old implementation's goroutine sits blocked on select for as long
+// as the subscription lives — potentially the process lifetime).
+//
+// So this holds 10k subscriptions open simultaneously and asserts
+// NumGoroutine does NOT grow anywhere near 10k while they're all live —
+// the context.AfterFunc-based implementation registers no goroutine at
+// all for context.Background().
+func TestSubscribeForever_10kHeldOpen_NoPerSubscriptionGoroutine(t *testing.T) {
+	const n = 10_000
+
+	sig := signals.New(0)
+
+	runtime.GC()
+	runtime.Gosched()
+	baseline := runtime.NumGoroutine()
+
+	unsubs := make([]signals.Unsubscribe, n)
+	for i := range n {
+		unsubs[i] = sig.SubscribeForever(func(int) {})
+	}
+
+	runtime.Gosched()
+	held := runtime.NumGoroutine() - baseline
+	if held > n/10 {
+		t.Errorf("NumGoroutine grew by %d while %d subscriptions were held open, want << %d (goroutine parked per Subscribe)",
+			held, n, n)
+	}
+
+	for _, unsub := range unsubs {
+		unsub()
+	}
+
+	runtime.GC()
+	runtime.Gosched()
+	delta := runtime.NumGoroutine() - baseline
+	if delta > 10 {
+		t.Errorf("NumGoroutine delta = %d after unsubscribing all %d, want <= 10", delta, n)
+	}
+}
+
+// TestSubscribe_ConcurrentCancelAndUnsubscribe_NoRace pins the
+// close-close race: the pre-fix implementation raced two different
+// close(done) call sites (context cancellation vs. manual Unsubscribe)
+// guarded only by a non-atomic select-with-default, which could panic
+// with "close of closed channel" when both fired at once. The
+// context.AfterFunc + sync.Once rewrite must make concurrent
+// cancel+unsubscribe race-free. Run with -race to also catch any data
+// race, not just panics.
+func TestSubscribe_ConcurrentCancelAndUnsubscribe_NoRace(t *testing.T) {
+	const cycles = 10_000
+
+	sig := signals.New(0)
+
+	var wg sync.WaitGroup
+	for range cycles {
+		ctx, cancel := context.WithCancel(context.Background())
+		unsub := sig.Subscribe(ctx, func(int) {})
+
+		wg.Go(cancel)
+		wg.Go(unsub)
+	}
+	wg.Wait()
+}

From 6de40b68ec2d252a6960d0e4411d3bc2cdc3dc6e Mon Sep 17 00:00:00 2001
From: Andrey Kolkov <a.kolkov@gmail.com>
Date: Wed, 15 Jul 2026 14:40:21 +0300
Subject: [PATCH 2/5] perf: reduce Effect_Create allocations from 9 to 7
 (ADR-001)

Four independent optimizations:

- Pre-allocate unsubscribes slice with known dep count
- Cache AsReadonly() in signal struct (lazy init, same pointer on every call)
- Capture e.run method value once before dep loop (avoids N closures for N deps)
- Dual-path Effect: store fnSimple directly, skip wrapper closure allocation

Effect_Create(1dep): 1560ns/384B/10allocs -> 352ns/196B/7allocs (4.4x)
Effect_Create(3deps): 4620ns/1016B/24allocs -> 726ns/388B/13allocs (6.4x)
Signal_Subscribe: 745ns/224B/3allocs -> 134ns/52B/2allocs (5.6x)

Remaining 7 allocs are near-irreducible: effect struct, subscribe
closure+atomic, type-erased callback, method value, slice header.
---
 effect.go | 81 ++++++++++++++++++++++++++++++++-----------------------
 signal.go | 11 ++++++--
 2 files changed, 56 insertions(+), 36 deletions(-)

diff --git a/effect.go b/effect.go
index cc3b2e7..2541314 100644
--- a/effect.go
+++ b/effect.go
@@ -22,9 +22,13 @@ type EffectRef interface {
 
 // effect is the internal implementation of Effect.
 type effect struct {
-	// fn is the effect function that may return a cleanup function
+	// fn is the effect function that returns a cleanup function (EffectWithCleanup path)
 	fn func() func()
 
+	// fnSimple is the effect function without cleanup (Effect path).
+	// When set, fn is nil — avoids a wrapper closure allocation.
+	fnSimple func()
+
 	// cleanup is the current cleanup function from the last run
 	cleanup func()
 
@@ -70,12 +74,7 @@ type effect struct {
 //
 // For effects that need cleanup, use EffectWithCleanup instead.
 func Effect(fn func(), deps ...any) EffectRef {
-	// Wrap fn to match cleanup signature (returns nil cleanup)
-	wrappedFn := func() func() {
-		fn()
-		return nil
-	}
-	return EffectWithCleanup(wrappedFn, deps...)
+	return effectCreate(fn, nil, EffectOptions{}, deps...)
 }
 
 // EffectWithCleanup creates an effect with cleanup callback support.
@@ -145,30 +144,31 @@ type EffectOptions struct {
 //	    count.AsReadonly(),
 //	)
 func EffectWithOptions(fn func() func(), opts EffectOptions, deps ...any) EffectRef {
+	return effectCreate(nil, fn, opts, deps...)
+}
+
+// effectCreate is the shared constructor for both Effect and EffectWithCleanup paths.
+// Exactly one of fnSimple or fn must be non-nil.
+func effectCreate(fnSimple func(), fn func() func(), opts EffectOptions, deps ...any) EffectRef {
 	e := &effect{
-		fn:      fn,
-		onPanic: opts.OnPanic,
+		fn:           fn,
+		fnSimple:     fnSimple,
+		onPanic:      opts.OnPanic,
+		unsubscribes: make([]Unsubscribe, 0, len(deps)),
 	}
 
-	// Track dependencies using type erasure (subscribe to changes)
+	runFn := e.run
 	for _, dep := range deps {
-		e.trackDependency(dep)
+		unsub := trackDependencyHelper(dep, runFn)
+		e.unsubscribes = append(e.unsubscribes, unsub)
 	}
 
 	// CRITICAL: Run effect IMMEDIATELY (Angular pattern)
-	// This MUST happen before returning the effect
 	e.run()
 
 	return e
 }
 
-// trackDependency registers a signal as a dependency using type erasure.
-// This subscribes to the dependency so the effect re-runs when it changes.
-func (e *effect) trackDependency(dep any) {
-	unsub := trackDependencyHelper(dep, e.run)
-	e.unsubscribes = append(e.unsubscribes, unsub)
-}
-
 // run executes the effect function with proper cleanup handling.
 //
 // Cleanup sequence:
@@ -211,23 +211,36 @@ func (e *effect) run() {
 		}()
 	}
 
-	// Step 2: Execute effect function and capture new cleanup
-	var newCleanup func()
-	func() {
-		defer func() {
-			if r := recover(); r != nil {
-				if e.onPanic != nil {
-					e.onPanic(r, debug.Stack())
-				} else {
-					log.Printf("signals: panic in effect function: %v\n%s", r, debug.Stack())
+	// Step 2: Execute effect function
+	if e.fnSimple != nil {
+		func() {
+			defer func() {
+				if r := recover(); r != nil {
+					if e.onPanic != nil {
+						e.onPanic(r, debug.Stack())
+					} else {
+						log.Printf("signals: panic in effect function: %v\n%s", r, debug.Stack())
+					}
 				}
-			}
+			}()
+			e.fnSimple()
 		}()
-		newCleanup = e.fn()
-	}()
-
-	// Step 3: Store new cleanup
-	e.cleanup = newCleanup
+	} else {
+		var newCleanup func()
+		func() {
+			defer func() {
+				if r := recover(); r != nil {
+					if e.onPanic != nil {
+						e.onPanic(r, debug.Stack())
+					} else {
+						log.Printf("signals: panic in effect function: %v\n%s", r, debug.Stack())
+					}
+				}
+			}()
+			newCleanup = e.fn()
+		}()
+		e.cleanup = newCleanup
+	}
 }
 
 // Stop stops the effect and runs final cleanup.
diff --git a/signal.go b/signal.go
index f8ab9aa..bb56380 100644
--- a/signal.go
+++ b/signal.go
@@ -33,6 +33,10 @@ type signal[T any] struct {
 	// metrics for observability (lock-free counters)
 	reads  atomic.Int64
 	writes atomic.Int64
+
+	// cached read-only view (initialized lazily by AsReadonly)
+	readonly     readonlySignal[T]
+	readonlyOnce sync.Once
 }
 
 // New creates a new writable signal with the given initial value.
@@ -221,9 +225,12 @@ func (s *signal[T]) SubscribeForever(fn func(T)) Unsubscribe {
 }
 
 // AsReadonly returns a read-only view of this signal.
-// Use for encapsulation - keep Signal private, expose ReadonlySignal.
+// Returns the same pointer on every call (cached after first initialization).
 func (s *signal[T]) AsReadonly() ReadonlySignal[T] {
-	return &readonlySignal[T]{source: s}
+	s.readonlyOnce.Do(func() {
+		s.readonly.source = s
+	})
+	return &s.readonly
 }
 
 // notifySubscribers calls all subscriber callbacks with panic recovery.

From 8355230bf37df4d7c55cf72d3b47ec3bb2e4ef73 Mon Sep 17 00:00:00 2001
From: Andrey Kolkov <a.kolkov@gmail.com>
Date: Wed, 15 Jul 2026 14:58:49 +0300
Subject: [PATCH 3/5] test: add allocation regression tests
 (testing.AllocsPerRun)

10 deterministic allocation-count tests that break the build
if heap allocations increase:

- Signal: Get(0), Set(0), Set+subscriber(1), SubscribeForever(2), Subscribe+ctx(5)
- Computed: Get cached(0), SubscribeForever(2)
- AsReadonly cached(0)
- Effect(7), EffectWithCleanup(7)

Unlike benchmark ns/op, AllocsPerRun counts are deterministic
and will catch any allocation regression immediately in CI.
---
 alloc_test.go | 145 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 145 insertions(+)
 create mode 100644 alloc_test.go

diff --git a/alloc_test.go b/alloc_test.go
new file mode 100644
index 0000000..6b1531c
--- /dev/null
+++ b/alloc_test.go
@@ -0,0 +1,145 @@
+package signals
+
+import (
+	"context"
+	"testing"
+)
+
+// Allocation regression tests.
+// These use testing.AllocsPerRun which is deterministic —
+// unlike benchmark ns/op, alloc counts don't fluctuate,
+// so any increase immediately fails the build.
+
+func TestAllocations_Signal_SubscribeForever(t *testing.T) {
+	sig := New(0)
+	allocs := testing.AllocsPerRun(100, func() {
+		unsub := sig.SubscribeForever(func(int) {})
+		unsub()
+	})
+	// 2 allocs: atomic.Bool escape + remove closure
+	if allocs > 2 {
+		t.Errorf("SubscribeForever: %.0f allocs, want <= 2", allocs)
+	}
+}
+
+func TestAllocations_Signal_SubscribeWithContext(t *testing.T) {
+	sig := New(0)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	allocs := testing.AllocsPerRun(100, func() {
+		unsub := sig.Subscribe(ctx, func(int) {})
+		unsub()
+	})
+	// 5 allocs: atomic.Bool + remove closure + wrapper closure + AfterFunc internals
+	if allocs > 5 {
+		t.Errorf("Subscribe(ctx): %.0f allocs, want <= 5", allocs)
+	}
+}
+
+func TestAllocations_Computed_SubscribeForever(t *testing.T) {
+	base := New(0)
+	comp := Computed(func() int { return base.Get() * 2 }, base.AsReadonly())
+
+	allocs := testing.AllocsPerRun(100, func() {
+		unsub := comp.SubscribeForever(func(int) {})
+		unsub()
+	})
+	if allocs > 2 {
+		t.Errorf("Computed.SubscribeForever: %.0f allocs, want <= 2", allocs)
+	}
+}
+
+func TestAllocations_Signal_Get(t *testing.T) {
+	sig := New(42)
+	allocs := testing.AllocsPerRun(100, func() {
+		_ = sig.Get()
+	})
+	if allocs > 0 {
+		t.Errorf("Get: %.0f allocs, want 0", allocs)
+	}
+}
+
+func TestAllocations_Signal_Set(t *testing.T) {
+	sig := New(0)
+	allocs := testing.AllocsPerRun(100, func() {
+		sig.Set(1)
+	})
+	// Set with no subscribers = 0 allocs (no callback slice created)
+	if allocs > 0 {
+		t.Errorf("Set (no subscribers): %.0f allocs, want 0", allocs)
+	}
+}
+
+func TestAllocations_Signal_SetWithSubscribers(t *testing.T) {
+	sig := New(0)
+	sig.SubscribeForever(func(int) {})
+
+	allocs := testing.AllocsPerRun(100, func() {
+		sig.Set(1)
+	})
+	// Set with subscribers: 1 alloc for callback slice copy
+	if allocs > 1 {
+		t.Errorf("Set (with subscriber): %.0f allocs, want <= 1", allocs)
+	}
+}
+
+func TestAllocations_Computed_Get_Cached(t *testing.T) {
+	base := New(42)
+	comp := Computed(func() int { return base.Get() * 2 }, base.AsReadonly())
+	_ = comp.Get() // prime cache
+
+	allocs := testing.AllocsPerRun(100, func() {
+		_ = comp.Get()
+	})
+	if allocs > 0 {
+		t.Errorf("Computed.Get (cached): %.0f allocs, want 0", allocs)
+	}
+}
+
+func TestAllocations_AsReadonly(t *testing.T) {
+	sig := New(42)
+	_ = sig.AsReadonly() // prime cache
+
+	allocs := testing.AllocsPerRun(100, func() {
+		_ = sig.AsReadonly()
+	})
+	// Cached: 0 allocs after first call
+	if allocs > 0 {
+		t.Errorf("AsReadonly (cached): %.0f allocs, want 0", allocs)
+	}
+}
+
+func TestAllocations_Effect_Create(t *testing.T) {
+	base := New(0)
+	readonly := base.AsReadonly()
+
+	allocs := testing.AllocsPerRun(20, func() {
+		eff := Effect(func() {
+			_ = base.Get()
+		}, readonly)
+		eff.Stop()
+	})
+	// 7 allocs: effect struct, pre-alloc slice, method value,
+	// type-erased callback, atomic.Bool, remove closure, make(slice)
+	if allocs > 7 {
+		t.Errorf("Effect (1 dep): %.0f allocs, want <= 7", allocs)
+	}
+}
+
+func TestAllocations_EffectWithCleanup_Create(t *testing.T) {
+	base := New(0)
+	readonly := base.AsReadonly()
+
+	allocs := testing.AllocsPerRun(20, func() {
+		eff := EffectWithCleanup(func() func() {
+			_ = base.Get()
+			return func() {}
+		}, readonly)
+		eff.Stop()
+	})
+	// 7 allocs: same as Effect but fn instead of fnSimple
+	if allocs > 7 {
+		t.Errorf("EffectWithCleanup (1 dep): %.0f allocs, want <= 7", allocs)
+	}
+}

From 17575c123e3273cf3274cb45f556e04b702b01e7 Mon Sep 17 00:00:00 2001
From: Andrey Kolkov <a.kolkov@gmail.com>
Date: Wed, 15 Jul 2026 15:10:37 +0300
Subject: [PATCH 4/5] docs: update README, CHANGELOG for v0.1.1; remove
 scripts/

- README: update test count (69), coverage (93.8%), benchmarks
  with post-optimization numbers, remove make/scripts references
- CHANGELOG: add v0.1.1 entry (goroutine leak fix, race fix,
  5.6x Subscribe speedup, allocation optimizations)
- Remove scripts/ directory (unused)
- Add tmp/ to .gitignore
- Remove /scripts/ from CODEOWNERS
---
 .github/CODEOWNERS            |   3 -
 .gitignore                    |   3 +
 CHANGELOG.md                  |  33 +++
 README.md                     |  65 ++---
 scripts/README.md             | 221 ---------------
 scripts/pre-release-check.bat |  22 --
 scripts/pre-release-check.sh  | 493 ----------------------------------
 7 files changed, 57 insertions(+), 783 deletions(-)
 delete mode 100644 scripts/README.md
 delete mode 100644 scripts/pre-release-check.bat
 delete mode 100644 scripts/pre-release-check.sh

diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index 77a6f13..ed031c8 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -27,9 +27,6 @@
 # GitHub configuration and CI/CD
 /.github/ @kolkov
 
-# Scripts - Build automation and quality checks
-/scripts/ @kolkov
-
 # Tests - Ensure coverage and reliability
 *_test.go @kolkov
 *_bench_test.go @kolkov
diff --git a/.gitignore b/.gitignore
index 7aff1de..b068e63 100644
--- a/.gitignore
+++ b/.gitignore
@@ -28,6 +28,9 @@ go.work
 .goda/
 docs/dev/
 
+# Temporary files
+tmp/
+
 # OS files
 .DS_Store
 Thumbs.db
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 596c41d..3012190 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -16,6 +16,39 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Migration guides
 - Best practices documentation
 
+## [0.1.1] - 2026-07-15
+
+### Fixed
+
+- **Goroutine leak in Subscribe** — each `Subscribe` call spawned a goroutine that
+  blocked for the subscription lifetime. `SubscribeForever` (context.Background)
+  parked it forever. 10k subscriptions = 10k idle goroutines (20-40MB stack waste).
+  Replaced with `context.AfterFunc` — zero goroutines per subscription.
+  ([#6](https://github.com/coregx/signals/issues/6), reported by @AnyCPU)
+
+- **Race condition in Unsubscribe** — concurrent `cancel()` + `Unsubscribe()` could
+  both reach `close(done)` via non-atomic select-default guard, causing
+  `panic: close of closed channel`. Replaced with `atomic.Bool.CompareAndSwap`
+  for idempotent cleanup.
+  ([#6](https://github.com/coregx/signals/issues/6))
+
+### Performance
+
+- **Signal_Subscribe**: 745 ns → 134 ns (5.6x faster), 224B → 52B (−77% memory)
+- **Effect_Create (1 dep)**: 1560 ns → 352 ns (4.4x faster), 384B → 196B, 10 → 7 allocs
+- **Effect_Create (3 deps)**: 4620 ns → 726 ns (6.4x faster), 1016B → 388B, 24 → 13 allocs
+- **Effect_Stop**: OOM → 330 ns (goroutine accumulation eliminated)
+- **AsReadonly()**: cached after first call (zero allocs on subsequent calls)
+
+### Added
+
+- Allocation regression tests using `testing.AllocsPerRun` — deterministic, breaks
+  build if heap allocations increase
+- Subscribe lifecycle regression tests — goroutine leak detection (10k held subs)
+  and concurrent cancel+unsub race condition
+- Cached `AsReadonly()` — returns same pointer on every call
+- Dual-path `Effect` — avoids wrapper closure allocation for effects without cleanup
+
 ## [0.1.0] - 2025-10-31
 
 ### 🎉 First Stable Release
diff --git a/README.md b/README.md
index 85dd77d..d865607 100644
--- a/README.md
+++ b/README.md
@@ -26,7 +26,7 @@ A modern, production-grade reactive programming library for Go 1.25+ that brings
 - **Glitch-Free** - Atomic updates prevent intermediate states
 - **Lazy Evaluation** - Computed values calculate only when needed
 - **Effect Cleanup** - Automatic resource management with cleanup callbacks
-- **Production Ready** - 55 tests, 94.5% coverage, 28 benchmarks
+- **Production Ready** - 69 tests, 93.8% coverage, 28 benchmarks
 
 ---
 
@@ -121,7 +121,7 @@ eff.Stop()  // Final cleanup runs, effect stops
 
 ## Current Status
 
-**Version**: v0.1.0 (Stable - Production-ready!)
+**Version**: v0.1.1 (unreleased)
 
 **Production Readiness: Core functionality complete and stable!**
 
@@ -161,26 +161,31 @@ eff.Stop()  // Final cleanup runs, effect stops
 
 | Package | Tests | Coverage | Benchmarks |
 |---------|-------|----------|------------|
-| signals | 55    | 94.5%    | 28         |
+| signals | 69    | 93.8%    | 28         |
 
 **Key Metrics**:
 - 19 Signal tests
 - 17 Computed tests
 - 16 Effect tests
 - 3 Internal tests (type erasure, reflection fallback)
+- 10 Allocation regression tests (`testing.AllocsPerRun`)
+- 2 Subscribe lifecycle regression tests (goroutine leak, race condition)
+- 2 Readonly cache tests
 - Zero allocations in signal read/write hot paths
-- Race detector clean (all tests pass with `-race`)
+- Race detector clean (all tests pass with `-race` in CI)
 
 ### Performance Characteristics
 
 ```
-BenchmarkSignal_Get            46738254     27.72 ns/op    0 B/op    0 allocs/op
-BenchmarkSignal_Set            20975720     52.42 ns/op    0 B/op    0 allocs/op
-BenchmarkComputed_Get_Clean    79329402     19.84 ns/op    0 B/op    0 allocs/op
-BenchmarkEffect_Execute         8391343    139.6  ns/op    0 B/op    0 allocs/op
+BenchmarkSignal_Get              96773490     13.46 ns/op     0 B/op    0 allocs/op
+BenchmarkSignal_Set              20975720     52.42 ns/op     0 B/op    0 allocs/op
+BenchmarkSignal_Subscribe        17057289    134   ns/op     52 B/op    2 allocs/op
+BenchmarkComputed_Get_Clean      96773490     13.46 ns/op     0 B/op    0 allocs/op
+BenchmarkEffect_Execute           8426302    136   ns/op      0 B/op    0 allocs/op
+BenchmarkEffect_Create            7097109    324   ns/op    196 B/op    7 allocs/op
 ```
 
-*Zero allocations in hot paths ensure minimal GC pressure*
+*Zero allocations in hot paths (Get, Set, Execute). Subscribe uses context.AfterFunc — no goroutine per subscription.*
 
 ### Remaining Work
 
@@ -214,49 +219,21 @@ See [ROADMAP.md](ROADMAP.md) for detailed timeline.
 git clone https://github.com/coregx/signals.git
 cd signals
 
-# Run tests
-make test
-
-# Run tests with race detector
-make test-race
-
-# Run benchmarks
-make benchmark
-
-# Run linter
-make lint
-```
-
-### Testing
-
-```bash
 # Run all tests
-go test ./...
+go test -v ./...
+
+# Run with race detector (Linux/macOS, or CI)
+go test -v -race ./...
 
 # Run with coverage
 go test -coverprofile=coverage.out ./...
 go tool cover -html=coverage.out
 
-# Run with race detector
-go test -race ./...
-
 # Run benchmarks
 go test -bench=. -benchmem ./...
-```
-
-### Code Quality
-
-This project maintains high code quality standards:
 
-```bash
-# Format code
-make fmt
-
-# Run linter (zero issues required)
-make lint
-
-# Run all pre-commit checks
-make pre-commit
+# Run linter
+golangci-lint run
 ```
 
 ---
@@ -335,7 +312,7 @@ This project is licensed under the MIT License - see the [LICENSE](LICENSE) file
 ---
 
 **Status**: Stable - Production-ready!
-**Version**: v0.1.0
+**Version**: v0.1.1
 
 ---
 
diff --git a/scripts/README.md b/scripts/README.md
deleted file mode 100644
index a9ba7bb..0000000
--- a/scripts/README.md
+++ /dev/null
@@ -1,221 +0,0 @@
-# Scripts - Automation Tools
-
-Scripts for automating development and release tasks.
-
----
-
-## 📋 Available Scripts
-
-### pre-release-check.sh / .bat
-
-**Purpose**: Comprehensive quality validation before creating a release
-
-**Runs**:
-- ✅ Go version check (1.23+)
-- ✅ Git status validation
-- ✅ Code formatting (gofmt)
-- ✅ Go vet
-- ✅ Build verification
-- ✅ go.mod validation
-- ✅ **Tests with race detector** (CRITICAL!)
-- ✅ **Race detector stress test** (10 iterations)
-- ✅ **Coverage check** (90%+ required)
-- ✅ Benchmarks (performance targets)
-- ✅ golangci-lint (if available)
-- ✅ TODO/FIXME check
-- ✅ Documentation validation
-- ✅ Global state detection
-- ✅ API consistency checks
-- ✅ STATUS.md freshness check
-
-**Usage**:
-
-```bash
-# Linux/macOS/Git Bash
-./scripts/pre-release-check.sh
-
-# Windows
-scripts\pre-release-check.bat
-```
-
-**Exit Codes**:
-- `0` - All checks passed (or warnings only)
-- `1` - Critical errors detected
-
-**When to Run**:
-- Before creating release branch
-- Before merging to main
-- After major refactoring
-- Weekly as sanity check
-
----
-
-## 🎯 Quality Standards
-
-### Required for Release
-
-| Check | Requirement | Severity |
-|-------|-------------|----------|
-| Race conditions | 0 races | 🔴 CRITICAL |
-| Test coverage | ≥ 90% | 🔴 CRITICAL |
-| Go vet | 0 issues | 🔴 CRITICAL |
-| Build | Success | 🔴 CRITICAL |
-| Code format | gofmt clean | 🔴 CRITICAL |
-
-### Performance Targets
-
-| Metric | Target | Severity |
-|--------|--------|----------|
-| Signal.Get() | < 15ns/op | 🟡 WARNING |
-| Signal.Set() | < 200ns/op | 🟡 WARNING |
-| Subscribe | < 100ns/op | 🟡 WARNING |
-| Computed (clean) | < 15ns/op | 🟡 WARNING |
-
----
-
-## 🔧 Requirements
-
-### Minimum (Linux/macOS/Windows with Git Bash)
-
-- Go 1.23+
-- Git
-- GCC or Clang (for race detector)
-
-### Recommended
-
-- golangci-lint (for additional linting)
-
-### Installing GCC
-
-**Linux**:
-```bash
-sudo apt-get install gcc
-```
-
-**macOS**:
-```bash
-xcode-select --install
-```
-
-**Windows**:
-- Install [Git for Windows](https://git-scm.com/download/win) (includes Git Bash)
-- Install [mingw-w64](https://www.mingw-w64.org/) for GCC
-
----
-
-## 📊 Example Output
-
-```
-================================================
-  Signals Library - Pre-Release Check
-  Production-Ready Quality Validation
-================================================
-
-[INFO] Checking Go version...
-[SUCCESS] Go version: go1.23.1
-
-[INFO] Checking git status...
-[SUCCESS] Working directory is clean
-
-[INFO] Checking code formatting (gofmt -l .)...
-[SUCCESS] All files are properly formatted
-
-[INFO] Running go vet...
-[SUCCESS] go vet passed
-
-[INFO] Building all packages...
-[SUCCESS] Build successful
-
-[INFO] Running tests with race detector...
-[SUCCESS] All tests passed with race detector (0 races)
-
-[INFO] Running race detector stress test (10 iterations)...
-[SUCCESS] Race detector stress test passed (10/10)
-
-[INFO] Checking test coverage...
-  • Total coverage: 92.5%
-[SUCCESS] Coverage meets requirement (≥90%)
-
-[INFO] Running benchmarks...
-[SUCCESS] Benchmarks completed
-  • Signal.Get(): 12.3ns/op
-[SUCCESS] Signal.Get() meets target (<15ns/op)
-  • Signal.Set(): 185ns/op
-[SUCCESS] Signal.Set() meets target (<200ns/op)
-
-================================================
-  Summary
-================================================
-
-[SUCCESS] ✅ All checks passed! Ready for release.
-
-Next steps for release:
-  1. Update .claude/STATUS.md with release milestone
-  2. Create release branch: git checkout -b release/vX.Y.Z
-  3. Update version in go.mod (if applicable)
-  4. Create CHANGELOG.md entry
-  5. Commit: git commit -m 'chore: prepare vX.Y.Z release'
-  ...
-```
-
----
-
-## 🚨 Common Issues
-
-### Race Detector Not Available
-
-**Error**:
-```
-[ERROR] GCC/Clang not found - race detector REQUIRED
-```
-
-**Fix**: Install GCC/Clang (see Requirements above)
-
-### Coverage Below 90%
-
-**Error**:
-```
-[ERROR] Coverage below 90% (85.2%)
-Signals library requires 90%+ coverage for production
-```
-
-**Fix**: Add more unit tests, especially for:
-- Edge cases
-- Error paths
-- Concurrent scenarios
-
-### Uncommitted Changes
-
-**Warning**:
-```
-[WARNING] Uncommitted changes detected
-```
-
-**Fix**: Commit or stash changes before release
-
-### go.mod Needs Tidying
-
-**Warning**:
-```
-[WARNING] go.mod needs tidying (run 'go mod tidy')
-```
-
-**Fix**:
-```bash
-go mod tidy
-git add go.mod go.sum
-git commit -m "chore: tidy go.mod"
-```
-
----
-
-## 📝 Notes
-
-- **Windows users**: The `.bat` file automatically calls the `.sh` script via Git Bash
-- **CI/CD**: This script should match CI pipeline checks exactly
-- **Race detector**: Signals library REQUIRES race detector validation (thread-safety critical)
-- **Coverage**: 90%+ is non-negotiable for production-ready reactive library
-
----
-
-*Last Updated: 2025-10-31*
diff --git a/scripts/pre-release-check.bat b/scripts/pre-release-check.bat
deleted file mode 100644
index 0655e16..0000000
--- a/scripts/pre-release-check.bat
+++ /dev/null
@@ -1,22 +0,0 @@
-@echo off
-REM Pre-Release Check - Windows Wrapper
-REM This script calls the bash version for consistency
-
-REM Check if bash is available
-where bash >nul 2>&1
-if %errorlevel% neq 0 (
-    echo Error: bash not found in PATH
-    echo.
-    echo Please install Git Bash or WSL to run this script
-    echo Download Git for Windows: https://git-scm.com/download/win
-    echo.
-    pause
-    exit /b 1
-)
-
-REM Get script directory
-set SCRIPT_DIR=%~dp0
-
-REM Run bash script
-bash "%SCRIPT_DIR%pre-release-check.sh"
-exit /b %errorlevel%
diff --git a/scripts/pre-release-check.sh b/scripts/pre-release-check.sh
deleted file mode 100644
index 33feacd..0000000
--- a/scripts/pre-release-check.sh
+++ /dev/null
@@ -1,493 +0,0 @@
-#!/usr/bin/env bash
-# Pre-Release Validation Script for Signals Library
-# This script runs all quality checks before creating a release
-# Ensures production-ready quality standards
-
-set -e  # Exit on first error
-
-# Colors for output
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-NC='\033[0m' # No Color
-
-# Logging functions
-log_info() {
-    echo -e "${BLUE}[INFO]${NC} $1"
-}
-
-log_success() {
-    echo -e "${GREEN}[SUCCESS]${NC} $1"
-}
-
-log_warning() {
-    echo -e "${YELLOW}[WARNING]${NC} $1"
-}
-
-log_error() {
-    echo -e "${RED}[ERROR]${NC} $1"
-}
-
-# Header
-echo ""
-echo "================================================"
-echo "  Signals Library - Pre-Release Check"
-echo "  Production-Ready Quality Validation"
-echo "================================================"
-echo ""
-
-# Track overall status
-ERRORS=0
-WARNINGS=0
-
-# 1. Check Go version
-log_info "Checking Go version..."
-GO_VERSION=$(go version | awk '{print $3}')
-REQUIRED_VERSION="go1.23"
-if [[ "$GO_VERSION" < "$REQUIRED_VERSION" ]]; then
-    log_error "Go version $REQUIRED_VERSION+ required, found $GO_VERSION"
-    ERRORS=$((ERRORS + 1))
-else
-    log_success "Go version: $GO_VERSION"
-fi
-echo ""
-
-# 2. Check git status
-log_info "Checking git status..."
-if git diff-index --quiet HEAD --; then
-    log_success "Working directory is clean"
-else
-    log_warning "Uncommitted changes detected"
-    git status --short
-    WARNINGS=$((WARNINGS + 1))
-fi
-echo ""
-
-# 3. Code formatting check
-log_info "Checking code formatting (gofmt -l .)..."
-UNFORMATTED=$(gofmt -l . 2>/dev/null || true)
-if [ -n "$UNFORMATTED" ]; then
-    # Filter out vendor directories if any
-    UNFORMATTED=$(echo "$UNFORMATTED" | grep -v "^vendor/" || true)
-fi
-
-if [ -n "$UNFORMATTED" ]; then
-    log_error "The following files need formatting:"
-    echo "$UNFORMATTED"
-    echo ""
-    log_info "Run: go fmt ./..."
-    ERRORS=$((ERRORS + 1))
-else
-    log_success "All files are properly formatted"
-fi
-echo ""
-
-# 4. Go vet
-log_info "Running go vet..."
-if go vet ./... 2>&1; then
-    log_success "go vet passed"
-else
-    log_error "go vet failed"
-    ERRORS=$((ERRORS + 1))
-fi
-echo ""
-
-# 5. Build all packages
-log_info "Building all packages..."
-if go build ./... 2>&1; then
-    log_success "Build successful"
-else
-    log_error "Build failed"
-    ERRORS=$((ERRORS + 1))
-fi
-echo ""
-
-# 6. go.mod validation
-log_info "Validating go.mod..."
-go mod verify
-if [ $? -eq 0 ]; then
-    log_success "go.mod verified"
-else
-    log_error "go.mod verification failed"
-    ERRORS=$((ERRORS + 1))
-fi
-
-# Check if go.mod needs tidying
-go mod tidy
-if git diff --quiet go.mod go.sum 2>/dev/null; then
-    log_success "go.mod is tidy"
-else
-    log_warning "go.mod needs tidying (run 'go mod tidy')"
-    git diff go.mod go.sum 2>/dev/null || true
-    WARNINGS=$((WARNINGS + 1))
-fi
-echo ""
-
-# 6.5. Verify golangci-lint configuration
-log_info "Verifying golangci-lint configuration..."
-if command -v golangci-lint &> /dev/null; then
-    if golangci-lint config verify 2>&1; then
-        log_success "golangci-lint config is valid"
-    else
-        log_error "golangci-lint config is invalid"
-        ERRORS=$((ERRORS + 1))
-    fi
-else
-    log_warning "golangci-lint not installed - skipping config verification"
-    WARNINGS=$((WARNINGS + 1))
-fi
-echo ""
-
-# 7. Run tests with race detector (CRITICAL for signals library!)
-USE_WSL=0
-WSL_DISTRO=""
-
-# Helper function to find WSL distro with Go installed
-find_wsl_distro() {
-    if ! command -v wsl &> /dev/null; then
-        return 1
-    fi
-
-    # Try common distros first
-    for distro in "Gentoo" "Ubuntu" "Debian" "Alpine"; do
-        if wsl -d "$distro" bash -c "command -v go &> /dev/null" 2>/dev/null; then
-            echo "$distro"
-            return 0
-        fi
-    done
-
-    return 1
-}
-
-if command -v gcc &> /dev/null || command -v clang &> /dev/null; then
-    log_info "Running tests with race detector..."
-    RACE_FLAG="-race"
-    TEST_CMD="go test -race ./... 2>&1"
-else
-    # Try to find WSL distro with Go
-    WSL_DISTRO=$(find_wsl_distro)
-    if [ -n "$WSL_DISTRO" ]; then
-        log_info "GCC not found locally, but WSL2 ($WSL_DISTRO) detected!"
-        log_info "Running tests with race detector via WSL2 $WSL_DISTRO..."
-        USE_WSL=1
-        RACE_FLAG="-race"
-
-        # Convert Windows path to WSL path (D:\projects\signals -> /mnt/d/projects/signals)
-        # pwd in MSYS returns /d/projects/signals, need to convert to /mnt/d/projects/signals
-        CURRENT_DIR=$(pwd)
-        if [[ "$CURRENT_DIR" =~ ^/([a-z])/ ]]; then
-            # Already in /d/... format (MSYS), convert to /mnt/d/...
-            WSL_PATH="/mnt${CURRENT_DIR}"
-        else
-            # Windows format D:\... convert to /mnt/d/...
-            DRIVE_LETTER=$(echo "$CURRENT_DIR" | cut -d: -f1 | tr '[:upper:]' '[:lower:]')
-            PATH_WITHOUT_DRIVE=${CURRENT_DIR#*:}
-            WSL_PATH="/mnt/$DRIVE_LETTER${PATH_WITHOUT_DRIVE//\\//}"
-        fi
-
-        TEST_CMD="wsl -d \"$WSL_DISTRO\" bash -c \"cd \\\"$WSL_PATH\\\" && go test -race ./... 2>&1\""
-    else
-        log_warning "GCC not found, running tests WITHOUT race detector"
-        log_info "Install GCC (mingw-w64) or setup WSL2 with Go for race detection"
-        log_info "  Windows: https://www.mingw-w64.org/"
-        log_info "  WSL2: https://docs.microsoft.com/en-us/windows/wsl/install"
-        WARNINGS=$((WARNINGS + 1))
-        RACE_FLAG=""
-        TEST_CMD="go test ./... 2>&1"
-    fi
-fi
-
-if [ $USE_WSL -eq 1 ]; then
-    TEST_OUTPUT=$(eval "$TEST_CMD")
-else
-    TEST_OUTPUT=$(eval "$TEST_CMD")
-fi
-
-# Check if race detector failed to build (known issue with some Go versions)
-if echo "$TEST_OUTPUT" | grep -q "hole in findfunctab\|build failed.*race"; then
-    log_warning "Race detector build failed (known Go runtime issue)"
-    log_info "Falling back to tests without race detector..."
-
-    if [ $USE_WSL -eq 1 ]; then
-        TEST_CMD="wsl -d \"$WSL_DISTRO\" bash -c \"cd \\\"$WSL_PATH\\\" && go test ./... 2>&1\""
-    else
-        TEST_CMD="go test ./... 2>&1"
-    fi
-
-    TEST_OUTPUT=$(eval "$TEST_CMD")
-    RACE_FLAG=""
-    WARNINGS=$((WARNINGS + 1))
-fi
-
-if echo "$TEST_OUTPUT" | grep -q "FAIL"; then
-    log_error "Tests failed or race conditions detected"
-    echo "$TEST_OUTPUT"
-    echo ""
-    if [ -n "$RACE_FLAG" ]; then
-        log_error "Race conditions are CRITICAL failures for signals library!"
-    fi
-    ERRORS=$((ERRORS + 1))
-elif echo "$TEST_OUTPUT" | grep -q "PASS\|ok"; then
-    if [ $USE_WSL -eq 1 ] && [ -n "$RACE_FLAG" ]; then
-        log_success "All tests passed with race detector (via WSL2 $WSL_DISTRO)"
-    elif [ -n "$RACE_FLAG" ]; then
-        log_success "All tests passed with race detector (0 races)"
-    else
-        log_success "All tests passed (race detector not available)"
-    fi
-else
-    log_error "Unexpected test output"
-    echo "$TEST_OUTPUT"
-    ERRORS=$((ERRORS + 1))
-fi
-echo ""
-
-# 8. Stress test race detector (signals-specific)
-if [ -n "$RACE_FLAG" ]; then
-    log_info "Running race detector stress test (10 iterations)..."
-    RACE_STRESS_PASS=true
-    for i in {1..10}; do
-        if [ $USE_WSL -eq 1 ]; then
-            if ! wsl -d "$WSL_DISTRO" bash -c "cd \"$WSL_PATH\" && go test -race -count=1 ./... 2>&1" &> /dev/null; then
-                RACE_STRESS_PASS=false
-                break
-            fi
-        else
-            if ! go test -race -count=1 ./... &> /dev/null; then
-                RACE_STRESS_PASS=false
-                break
-            fi
-        fi
-    done
-
-    if [ "$RACE_STRESS_PASS" = true ]; then
-        log_success "Race detector stress test passed (10/10)"
-    else
-        log_error "Race detector stress test failed at iteration $i"
-        ERRORS=$((ERRORS + 1))
-    fi
-else
-    log_warning "Race detector not available, skipping stress test"
-    WARNINGS=$((WARNINGS + 1))
-fi
-echo ""
-
-# 9. Test coverage check (CRITICAL: 90%+ requirement)
-log_info "Checking test coverage..."
-COVERAGE_FILE=$(mktemp)
-go test -cover -coverprofile="$COVERAGE_FILE" ./... > /dev/null 2>&1
-COVERAGE=$(go tool cover -func="$COVERAGE_FILE" 2>/dev/null | grep "total:" | awk '{print $3}' | sed 's/%//')
-rm -f "$COVERAGE_FILE"
-
-if [ -n "$COVERAGE" ]; then
-    echo "  • Total coverage: ${COVERAGE}%"
-    if awk -v cov="$COVERAGE" 'BEGIN {exit !(cov >= 90.0)}'; then
-        log_success "Coverage meets requirement (≥90%)"
-    else
-        log_error "Coverage below 90% (${COVERAGE}%)"
-        log_error "Signals library requires 90%+ coverage for production"
-        ERRORS=$((ERRORS + 1))
-    fi
-else
-    log_error "Could not determine coverage"
-    ERRORS=$((ERRORS + 1))
-fi
-echo ""
-
-# 10. Benchmarks validation
-log_info "Running benchmarks..."
-BENCH_FILE=$(mktemp)
-if go test -bench=. -benchmem ./... > "$BENCH_FILE" 2>&1; then
-    log_success "Benchmarks completed"
-
-    # Check Signal.Get performance (target: < 15ns/op)
-    SIGNAL_GET=$(grep "BenchmarkSignal.*Get" "$BENCH_FILE" 2>/dev/null | awk '{print $3}' | head -1 | sed 's/ns\/op//')
-    if [ -n "$SIGNAL_GET" ]; then
-        echo "  • Signal.Get(): ${SIGNAL_GET}ns/op"
-        if awk -v perf="$SIGNAL_GET" 'BEGIN {exit !(perf < 15)}'; then
-            log_success "Signal.Get() meets target (<15ns/op)"
-        else
-            log_warning "Signal.Get() slower than target (${SIGNAL_GET}ns/op vs 15ns/op)"
-            WARNINGS=$((WARNINGS + 1))
-        fi
-    fi
-
-    # Check Signal.Set performance (target: < 200ns/op)
-    SIGNAL_SET=$(grep "BenchmarkSignal.*Set" "$BENCH_FILE" 2>/dev/null | awk '{print $3}' | head -1 | sed 's/ns\/op//')
-    if [ -n "$SIGNAL_SET" ]; then
-        echo "  • Signal.Set(): ${SIGNAL_SET}ns/op"
-        if awk -v perf="$SIGNAL_SET" 'BEGIN {exit !(perf < 200)}'; then
-            log_success "Signal.Set() meets target (<200ns/op)"
-        else
-            log_warning "Signal.Set() slower than target (${SIGNAL_SET}ns/op vs 200ns/op)"
-            WARNINGS=$((WARNINGS + 1))
-        fi
-    fi
-else
-    log_warning "Benchmarks not yet implemented or failed"
-    WARNINGS=$((WARNINGS + 1))
-fi
-rm -f "$BENCH_FILE"
-echo ""
-
-# 11. golangci-lint (if available)
-log_info "Running golangci-lint..."
-if command -v golangci-lint &> /dev/null; then
-    if golangci-lint run --timeout=5m ./... 2>&1 | tail -5 | grep -q "0 issues"; then
-        log_success "golangci-lint passed with 0 issues"
-    else
-        log_warning "Linter found issues"
-        golangci-lint run --timeout=5m ./... 2>&1 | tail -10
-        WARNINGS=$((WARNINGS + 1))
-    fi
-else
-    log_warning "golangci-lint not installed (optional but recommended)"
-    log_info "Install: https://golangci-lint.run/welcome/install/"
-    WARNINGS=$((WARNINGS + 1))
-fi
-echo ""
-
-# 12. Check for critical TODO/FIXME comments in production code
-log_info "Checking for TODO/FIXME comments in production code..."
-TODO_COUNT=$(grep -r "TODO\|FIXME" --include="*.go" --exclude-dir=vendor --exclude="*_test.go" . 2>/dev/null | wc -l)
-if [ "$TODO_COUNT" -gt 0 ]; then
-    log_warning "Found $TODO_COUNT TODO/FIXME comments in production code"
-    grep -r "TODO\|FIXME" --include="*.go" --exclude-dir=vendor --exclude="*_test.go" . 2>/dev/null | head -5
-    log_info "Consider resolving before release"
-    WARNINGS=$((WARNINGS + 1))
-else
-    log_success "No TODO/FIXME comments in production code"
-fi
-echo ""
-
-# 13. Check documentation (signals-specific)
-log_info "Checking documentation..."
-DOCS_MISSING=0
-REQUIRED_DOCS=".claude/QUICKREF.md .claude/STATUS.md .claude/CLAUDE.md docs/dev/IMPLEMENTATION_GUIDE.md docs/dev/ARCHITECTURE.md"
-
-for doc in $REQUIRED_DOCS; do
-    if [ ! -f "$doc" ]; then
-        log_error "Missing critical doc: $doc"
-        DOCS_MISSING=1
-        ERRORS=$((ERRORS + 1))
-    fi
-done
-
-# Check if public docs are ready (for v1.0+)
-if [ -f "README.md" ] && [ -f "API.md" ] && [ -f "GUIDE.md" ]; then
-    log_success "Public documentation complete (README, API, GUIDE)"
-elif [[ "$VERSION" == v1.* ]]; then
-    log_error "Public documentation required for v1.0+ releases"
-    DOCS_MISSING=1
-    ERRORS=$((ERRORS + 1))
-else
-    log_info "Public documentation not yet required (pre-v1.0)"
-fi
-
-if [ $DOCS_MISSING -eq 0 ]; then
-    log_success "All critical documentation present"
-fi
-echo ""
-
-# 14. Check for global state (signals anti-pattern)
-log_info "Checking for global state (anti-pattern for signals)..."
-GLOBAL_VARS=$(grep -r "^var.*=" --include="*.go" --exclude="*_test.go" --exclude-dir=vendor . 2>/dev/null | grep -v "^var.*func" | grep -v "^var.*interface" | wc -l)
-if [ "$GLOBAL_VARS" -gt 0 ]; then
-    log_warning "Found $GLOBAL_VARS potential global variables (review required)"
-    grep -r "^var.*=" --include="*.go" --exclude="*_test.go" --exclude-dir=vendor . 2>/dev/null | grep -v "^var.*func" | grep -v "^var.*interface" | head -5
-    log_info "Signals library should avoid global state"
-    WARNINGS=$((WARNINGS + 1))
-else
-    log_success "No global state detected"
-fi
-echo ""
-
-# 15. Check API consistency (signals-specific)
-log_info "Checking API consistency..."
-API_ISSUES=0
-
-# Check for ReadonlySignal interface
-if ! grep -q "type ReadonlySignal\[" *.go 2>/dev/null; then
-    log_error "ReadonlySignal interface not found (required for v1.0)"
-    API_ISSUES=1
-    ERRORS=$((ERRORS + 1))
-fi
-
-# Check for AsReadonly method
-if ! grep -q "AsReadonly()" *.go 2>/dev/null; then
-    log_warning "AsReadonly() method not found (encapsulation pattern)"
-    API_ISSUES=1
-    WARNINGS=$((WARNINGS + 1))
-fi
-
-# Check for context.Context support
-if ! grep -q "context.Context" *.go 2>/dev/null; then
-    log_warning "context.Context support not detected"
-    API_ISSUES=1
-    WARNINGS=$((WARNINGS + 1))
-fi
-
-if [ $API_ISSUES -eq 0 ]; then
-    log_success "API consistency checks passed"
-fi
-echo ""
-
-# 16. Check STATUS.md is up-to-date
-log_info "Checking STATUS.md..."
-if [ -f ".claude/STATUS.md" ]; then
-    LAST_UPDATE=$(grep "Last Updated" .claude/STATUS.md | head -1 | awk '{print $4}')
-    TODAY=$(date +%Y-%m-%d)
-
-    if [ "$LAST_UPDATE" == "$TODAY" ]; then
-        log_success "STATUS.md updated today"
-    else
-        log_warning "STATUS.md last updated: $LAST_UPDATE (consider updating)"
-        WARNINGS=$((WARNINGS + 1))
-    fi
-else
-    log_warning "STATUS.md not found"
-    WARNINGS=$((WARNINGS + 1))
-fi
-echo ""
-
-# Summary
-echo "================================================"
-echo "  Summary"
-echo "================================================"
-echo ""
-
-if [ $ERRORS -eq 0 ] && [ $WARNINGS -eq 0 ]; then
-    log_success "✅ All checks passed! Ready for release."
-    echo ""
-    log_info "Next steps for release:"
-    echo "  1. Update .claude/STATUS.md with release milestone"
-    echo "  2. Create release branch: git checkout -b release/vX.Y.Z"
-    echo "  3. Update version in go.mod (if applicable)"
-    echo "  4. Create CHANGELOG.md entry"
-    echo "  5. Commit: git commit -m 'chore: prepare vX.Y.Z release'"
-    echo "  6. Push and create PR: git push origin release/vX.Y.Z"
-    echo "  7. After PR merge, create tag: git tag -a vX.Y.Z -m 'Release vX.Y.Z'"
-    echo "  8. Push tag: git push origin vX.Y.Z"
-    echo "  9. Create GitHub release with notes"
-    echo ""
-    exit 0
-elif [ $ERRORS -eq 0 ]; then
-    log_warning "⚠️  Checks completed with $WARNINGS warning(s)"
-    echo ""
-    log_info "Review warnings above. Consider fixing before release."
-    echo ""
-    exit 0
-else
-    log_error "❌ Checks failed with $ERRORS error(s) and $WARNINGS warning(s)"
-    echo ""
-    log_error "CRITICAL: Fix all errors before creating release"
-    echo ""
-    log_info "Common fixes:"
-    echo "  • Race conditions: Review ARCHITECTURE.md for thread-safety patterns"
-    echo "  • Coverage < 90%: Add more unit tests"
-    echo "  • Format issues: Run 'go fmt ./...'"
-    echo "  • Go vet errors: Fix reported issues"
-    echo ""
-    exit 1
-fi

From be73112268eefcb48b896f813a59d2a701e4506e Mon Sep 17 00:00:00 2001
From: Andrey Kolkov <a.kolkov@gmail.com>
Date: Wed, 15 Jul 2026 15:13:51 +0300
Subject: [PATCH 5/5] docs: remove broken docs/dev/ links from public files
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

docs/dev/ is in .gitignore — links to it from README and
CONTRIBUTING were dead for anyone cloning the repo. Replace
with pkg.go.dev reference and inline design notes.
---
 CONTRIBUTING.md |  2 +-
 README.md       | 10 +++++-----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index c626d7d..e73961b 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -386,7 +386,7 @@ benchstat old.txt new.txt
 - **Documentation**: Check [docs/](docs/) and [README.md](README.md)
 - **Issues**: Search existing issues first
 - **Discussions**: Ask questions in GitHub Discussions
-- **Architecture**: Review [Architecture Overview](docs/dev/ARCHITECTURE.md)
+- **API Reference**: Review [pkg.go.dev](https://pkg.go.dev/github.com/coregx/signals)
 
 ## License
 
diff --git a/README.md b/README.md
index d865607..b212708 100644
--- a/README.md
+++ b/README.md
@@ -112,10 +112,10 @@ eff.Stop()  // Final cleanup runs, effect stops
 - **[API Reference](https://pkg.go.dev/github.com/coregx/signals)** - Complete API documentation
 - **[Examples](cmd/example/)** - Working code examples
 
-### Advanced
-- **[Architecture Overview](docs/dev/ARCHITECTURE.md)** - How it works internally
-- **[Implementation Guide](docs/dev/IMPLEMENTATION_GUIDE.md)** - Development guide
-- **[Angular Signals Analysis](docs/dev/ANGULAR_SIGNALS_ANALYSIS.md)** - Comparison with Angular
+### Design
+- **Angular-Inspired** - API design mirrors Angular Signals (see [Compatibility table](#angular-signals-compatibility))
+- **Explicit Dependencies** - Go requires explicit dependency passing (no auto-tracking like Angular)
+- **Zero Allocation Hot Paths** - Get/Set/Execute paths are allocation-free
 
 ---
 
@@ -245,7 +245,7 @@ Contributions are welcome! This is an early-stage project and we'd love your hel
 **Before contributing**:
 1. Read [CONTRIBUTING.md](CONTRIBUTING.md) - Development workflow and guidelines
 2. Check [open issues](https://github.com/coregx/signals/issues)
-3. Review the [Architecture Overview](docs/dev/ARCHITECTURE.md)
+3. Review the [API Reference](https://pkg.go.dev/github.com/coregx/signals)
 
 **Ways to contribute**:
 - Report bugs