@pi-in-go/pigpen-ahp 0.1.0

package/extensions/ahp/internal/svc/watchevents_test.go

@@ -0,0 +1,452 @@
+package svc
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/MichaelKinsy/pigpen/ahp/internal/testkit"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/twin"
+	ahptypes "github.com/microsoft/agent-host-protocol/clients/go/ahptypes"
+)
+
+// watchEvents is the test-side journal of one watch subscription: one reader per subscription, a
+// retained event journal, assertions that observe it (port of test/support/watch-events.ts).
+
+type batchSource interface {
+	// Next blocks for the next batch; it returns errStopped once stop closes.
+	Next(stop <-chan struct{}) ([]ahptypes.ResourceChange, error)
+}
+
+var errStopped = errors.New("watch reader stopped")
+
+type watchEvents struct {
+	src      batchSource
+	clock    Clock
+	describe func() any
+
+	mu      sync.Mutex
+	batches [][]ahptypes.ResourceChange
+	err     error
+	closed  bool
+	changed chan struct{}
+
+	stop    chan struct{}
+	reading chan struct{}
+}
+
+func newWatchEvents(src batchSource, clock Clock, describe func() any) *watchEvents {
+	if clock == nil {
+		clock = realClock{}
+	}
+	if describe == nil {
+		describe = func() any { return map[string]any{} }
+	}
+	e := &watchEvents{src: src, clock: clock, describe: describe, changed: make(chan struct{}), stop: make(chan struct{}), reading: make(chan struct{})}
+	go e.read()
+	return e
+}
+
+func (e *watchEvents) notifyLocked() {
+	close(e.changed)
+	e.changed = make(chan struct{})
+}
+
+func (e *watchEvents) read() {
+	defer close(e.reading)
+	for {
+		batch, err := e.src.Next(e.stop)
+		e.mu.Lock()
+		if e.closed {
+			e.mu.Unlock()
+			return
+		}
+		if err != nil {
+			e.err = err
+			e.notifyLocked()
+			e.mu.Unlock()
+			return
+		}
+		e.batches = append(e.batches, batch)
+		e.notifyLocked()
+		e.mu.Unlock()
+	}
+}
+
+func (e *watchEvents) changesLocked() []ahptypes.ResourceChange {
+	var all []ahptypes.ResourceChange
+	for _, b := range e.batches {
+		all = append(all, b...)
+	}
+	return all
+}
+
+func (e *watchEvents) Changes() []ahptypes.ResourceChange {
+	e.mu.Lock()
+	defer e.mu.Unlock()
+	return e.changesLocked()
+}
+
+func (e *watchEvents) Batches() [][]ahptypes.ResourceChange {
+	e.mu.Lock()
+	defer e.mu.Unlock()
+	return append([][]ahptypes.ResourceChange(nil), e.batches...)
+}
+
+func (e *watchEvents) Mark() int { return len(e.Changes()) }
+
+// WaitFor blocks until complete accepts the changes since a checkpoint. A timeout stops only this
+// assertion; it never starts or strands another read.
+func (e *watchEvents) WaitFor(label string, complete func([]ahptypes.ResourceChange) bool, since int, timeout time.Duration) ([]ahptypes.ResourceChange, error) {
+	timedOut := make(chan struct{})
+	timer := e.clock.AfterFunc(timeout, func() { close(timedOut) })
+	defer timer.Stop()
+	fail := func(cause error) error {
+		e.mu.Lock()
+		batches, _ := json.Marshal(e.batches)
+		e.mu.Unlock()
+		state, _ := json.Marshal(e.describe())
+		return fmt.Errorf("Expected %s; watch=%s; batches=%s: %w", label, state, batches, cause)
+	}
+	for {
+		e.mu.Lock()
+		if e.err != nil || e.closed {
+			err := e.err
+			if err == nil {
+				err = errors.New("Collector closed")
+			}
+			e.mu.Unlock()
+			return nil, fail(err)
+		}
+		changes := e.changesLocked()
+		if since > len(changes) {
+			since = len(changes)
+		}
+		changes = changes[since:]
+		if complete(changes) {
+			e.mu.Unlock()
+			return changes, nil
+		}
+		changed := e.changed
+		e.mu.Unlock()
+		select {
+		case <-changed:
+		case <-timedOut:
+			return nil, fail(errors.New("Timed out waiting for filesystem events"))
+		}
+	}
+}
+
+// Close ends the reader, settles pending assertions and reports a reader failure.
+func (e *watchEvents) Close() error {
+	e.mu.Lock()
+	if !e.closed {
+		e.closed = true
+		close(e.stop)
+		e.notifyLocked()
+	}
+	e.mu.Unlock()
+	<-e.reading
+	e.mu.Lock()
+	defer e.mu.Unlock()
+	return e.err
+}
+
+// clientSource reads resourceWatch/changed batches for one channel from a testkit client.
+type clientSource struct {
+	client  *testkit.Client
+	channel string
+}
+
+func (s clientSource) Next(stop <-chan struct{}) ([]ahptypes.ResourceChange, error) {
+	for {
+		n, ok := s.client.Await(func(n testkit.Notification) bool {
+			if n.Method != "action" {
+				return false
+			}
+			var p struct {
+				Channel string `json:"channel"`
+				Action  struct {
+					Type string `json:"type"`
+				} `json:"action"`
+			}
+			return json.Unmarshal(n.Params, &p) == nil && p.Channel == s.channel && p.Action.Type == string(ahptypes.ActionTypeResourceWatchChanged)
+		}, 20*time.Millisecond)
+		if ok {
+			var p struct {
+				Action struct {
+					Changes struct {
+						Items []ahptypes.ResourceChange `json:"items"`
+					} `json:"changes"`
+				} `json:"action"`
+			}
+			if err := json.Unmarshal(n.Params, &p); err != nil {
+				return nil, err
+			}
+			return p.Action.Changes.Items, nil
+		}
+		select {
+		case <-stop:
+			return nil, errStopped
+		default:
+		}
+	}
+}
+
+// ── a hand-driven clock ─────────────────────────────────────────────────
+
+type fakeClock struct {
+	mu     sync.Mutex
+	now    time.Duration
+	timers []*fakeTimer
+}
+
+type fakeTimer struct {
+	c       *fakeClock
+	at      time.Duration
+	f       func()
+	stopped bool
+	fired   bool
+}
+
+func (c *fakeClock) AfterFunc(d time.Duration, f func()) Stopper {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	t := &fakeTimer{c: c, at: c.now + d, f: f}
+	c.timers = append(c.timers, t)
+	return t
+}
+
+func (t *fakeTimer) Stop() bool {
+	t.c.mu.Lock()
+	defer t.c.mu.Unlock()
+	was := !t.stopped && !t.fired
+	t.stopped = true
+	return was
+}
+
+// Tick advances the clock and runs every timer that came due, in order.
+func (c *fakeClock) Tick(d time.Duration) {
+	c.mu.Lock()
+	target := c.now + d
+	c.mu.Unlock()
+	for {
+		c.mu.Lock()
+		var next *fakeTimer
+		for _, t := range c.timers {
+			if !t.stopped && !t.fired && t.at <= target && (next == nil || t.at < next.at) {
+				next = t
+			}
+		}
+		if next == nil {
+			c.now = target
+			c.mu.Unlock()
+			return
+		}
+		next.fired = true
+		if next.at > c.now {
+			c.now = next.at
+		}
+		c.mu.Unlock()
+		next.f()
+	}
+}
+
+// ── a scripted source ───────────────────────────────────────────────────
+
+type scriptedSource struct {
+	mu      sync.Mutex
+	reads   int
+	pending chan scriptedResult
+	t       *testing.T
+}
+
+type scriptedResult struct {
+	batch []ahptypes.ResourceChange
+	err   error
+}
+
+func (s *scriptedSource) Next(stop <-chan struct{}) ([]ahptypes.ResourceChange, error) {
+	s.mu.Lock()
+	if s.pending != nil {
+		s.mu.Unlock()
+		s.t.Error("only one Next may be outstanding")
+		return nil, errStopped
+	}
+	s.reads++
+	ch := make(chan scriptedResult, 1)
+	s.pending = ch
+	s.mu.Unlock()
+	select {
+	case r := <-ch:
+		return r.batch, r.err
+	case <-stop:
+		s.mu.Lock()
+		if s.pending == ch {
+			s.pending = nil // detaching does not settle an outstanding read, like the SDK
+		}
+		s.mu.Unlock()
+		return nil, errStopped
+	}
+}
+
+func (s *scriptedSource) Reads() int { s.mu.Lock(); defer s.mu.Unlock(); return s.reads }
+
+func (s *scriptedSource) resolve(r scriptedResult) {
+	// wait for the reader to park
+	for i := 0; i < 500; i++ {
+		s.mu.Lock()
+		ch := s.pending
+		s.pending = nil
+		s.mu.Unlock()
+		if ch != nil {
+			ch <- r
+			return
+		}
+		time.Sleep(2 * time.Millisecond)
+	}
+	s.t.Error("no read is outstanding")
+}
+
+func (s *scriptedSource) Push(items ...ahptypes.ResourceChange) {
+	s.resolve(scriptedResult{batch: items})
+}
+func (s *scriptedSource) Fail(err error) { s.resolve(scriptedResult{err: err}) }
+
+func addedChange(name string) ahptypes.ResourceChange {
+	return ahptypes.ResourceChange{Uri: "file:///" + name, Type: ahptypes.ResourceChangeTypeAdded}
+}
+
+func hasURI(uri string) func([]ahptypes.ResourceChange) bool {
+	return func(items []ahptypes.ResourceChange) bool {
+		for _, i := range items {
+			if i.Uri == uri {
+				return true
+			}
+		}
+		return false
+	}
+}
+
+// Twins of upstream test/watch-events.test.ts: regression tests for the journal itself.
+
+func TestWatchEventsJournal(t *testing.T) {
+	twin.Run(t, "watch-events", "watch assertions share a reader and retain the entire batch, even after a match", func(t *testing.T) {
+		input := &scriptedSource{t: t}
+		events := newWatchEvents(input, nil, nil)
+		defer events.Close()
+		type result struct {
+			changes []ahptypes.ResourceChange
+			err     error
+		}
+		first, second := make(chan result, 1), make(chan result, 1)
+		go func() { c, err := events.WaitFor("a", hasURI("file:///a"), 0, 4*time.Second); first <- result{c, err} }()
+		go func() { c, err := events.WaitFor("b", hasURI("file:///b"), 0, 4*time.Second); second <- result{c, err} }()
+		testkit.Eventually(t, "the single reader parks", func() bool { return input.Reads() == 1 })
+		input.Push(addedChange("a"), addedChange("b"))
+		want := []ahptypes.ResourceChange{addedChange("a"), addedChange("b")}
+		for _, ch := range []chan result{first, second} {
+			r := <-ch
+			if r.err != nil || fmt.Sprint(r.changes) != fmt.Sprint(want) {
+				t.Fatalf("%+v", r)
+			}
+		}
+		if got := events.Batches(); len(got) != 1 || fmt.Sprint(got[0]) != fmt.Sprint(want) {
+			t.Fatalf("batches %v", got)
+		}
+		again, err := events.WaitFor("already received b", hasURI("file:///b"), 0, 4*time.Second)
+		if err != nil || fmt.Sprint(again) != fmt.Sprint(events.Changes()) {
+			t.Fatalf("%v %v", again, err)
+		}
+	})
+
+	twin.Run(t, "watch-events", "a timed-out assertion neither steals the next batch nor accepts events before its checkpoint", func(t *testing.T) {
+		clock := &fakeClock{}
+		input := &scriptedSource{t: t}
+		events := newWatchEvents(input, clock, func() any { return map[string]any{"exists": true} })
+		defer events.Close()
+		testkit.Eventually(t, "reader parks", func() bool { return input.Reads() == 1 })
+		input.Push(addedChange("a"))
+		if _, err := events.WaitFor("first a", func(items []ahptypes.ResourceChange) bool { return len(items) == 1 }, 0, time.Minute); err != nil {
+			t.Fatal(err)
+		}
+		since := events.Mark()
+		rejected := make(chan error, 1)
+		go func() {
+			_, err := events.WaitFor("second a", func(items []ahptypes.ResourceChange) bool { return len(items) > 0 }, since, 10*time.Millisecond)
+			rejected <- err
+		}()
+		// the assertion must have armed its timer before the clock moves
+		testkit.Eventually(t, "the assertion armed its timer", func() bool { clock.mu.Lock(); defer clock.mu.Unlock(); return len(clock.timers) >= 2 })
+		clock.Tick(10 * time.Millisecond)
+		err := <-rejected
+		if err == nil {
+			t.Fatal("the assertion must time out")
+		}
+		for _, want := range []string{"second a", `"exists":true`, "file:///a"} {
+			if !contains(err.Error(), want) {
+				t.Fatalf("error %q lacks %q", err, want)
+			}
+		}
+		if input.Reads() != 2 {
+			t.Fatalf("timeout must not start another reader, reads=%d", input.Reads())
+		}
+		next := make(chan []ahptypes.ResourceChange, 1)
+		go func() {
+			c, _ := events.WaitFor("second a", func(items []ahptypes.ResourceChange) bool { return len(items) > 0 }, since, time.Minute)
+			next <- c
+		}()
+		input.Push(addedChange("a"))
+		if got := <-next; fmt.Sprint(got) != fmt.Sprint([]ahptypes.ResourceChange{addedChange("a")}) {
+			t.Fatalf("%v", got)
+		}
+		if n := len(events.Batches()); n != 2 {
+			t.Fatalf("%d batches", n)
+		}
+	})
+
+	twin.Run(t, "watch-events", "reports a reader failure during cleanup even without a waiting assertion", func(t *testing.T) {
+		input := &scriptedSource{t: t}
+		events := newWatchEvents(input, nil, nil)
+		failure := errors.New("subscription read failed")
+		testkit.Eventually(t, "reader parks", func() bool { return input.Reads() == 1 })
+		input.Fail(failure)
+		time.Sleep(20 * time.Millisecond)
+		if err := events.Close(); err != failure {
+			t.Fatalf("got %v", err)
+		}
+	})
+
+	twin.Run(t, "watch-events", "closing the journal settles pending assertions and the sole subscription reader", func(t *testing.T) {
+		input := &scriptedSource{t: t}
+		events := newWatchEvents(input, nil, nil)
+		rejected := make(chan error, 1)
+		go func() {
+			_, err := events.WaitFor("never arrives", func(items []ahptypes.ResourceChange) bool { return len(items) > 0 }, 0, 4*time.Second)
+			rejected <- err
+		}()
+		testkit.Eventually(t, "reader parks", func() bool { return input.Reads() == 1 })
+		time.Sleep(10 * time.Millisecond)
+		if err := events.Close(); err != nil && !errors.Is(err, errStopped) {
+			t.Fatal(err)
+		}
+		if err := <-rejected; err == nil {
+			t.Fatal("a pending assertion must be rejected when the journal closes")
+		}
+		if input.Reads() != 1 {
+			t.Fatalf("reads=%d", input.Reads())
+		}
+	})
+}
+
+func contains(s, sub string) bool {
+	for i := 0; i+len(sub) <= len(s); i++ {
+		if s[i:i+len(sub)] == sub {
+			return true
+		}
+	}
+	return false
+}

package/extensions/ahp/internal/svc/watchpolicy.go

@@ -0,0 +1,81 @@
+package svc
+
+import (
+	"path/filepath"
+	"strings"
+
+	ahptypes "github.com/microsoft/agent-host-protocol/clients/go/ahptypes"
+)
+
+// RelativeWatchPath is path relative to root in slash form: "" for the root itself, and ok=false
+// for a sibling, a parent or a prefix lookalike.
+func RelativeWatchPath(root, path string) (string, bool) {
+	abs, err := filepath.Abs(path)
+	if err != nil {
+		return "", false
+	}
+	rel, err := filepath.Rel(root, abs)
+	if err != nil || filepath.IsAbs(rel) || rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator)) {
+		return "", false
+	}
+	if rel == "." {
+		return "", true
+	}
+	return filepath.ToSlash(rel), true
+}
+
+// IsExcluded reports whether any exclude pattern matches path. The root ("") is never excluded.
+func IsExcluded(path string, excludes []string) bool {
+	if path == "" {
+		return false
+	}
+	for _, pattern := range excludes {
+		if matchesGlob(path, pattern) {
+			return true
+		}
+	}
+	return false
+}
+
+// MatchesPatterns applies include alternatives and exclude precedence; the root itself is always
+// in scope, filters describe its descendants.
+func MatchesPatterns(path string, includes, excludes []string) bool {
+	if path == "" {
+		return true
+	}
+	if IsExcluded(path, excludes) {
+		return false
+	}
+	if len(includes) == 0 {
+		return true
+	}
+	for _, pattern := range includes {
+		if matchesGlob(path, pattern) {
+			return true
+		}
+	}
+	return false
+}
+
+// MergeChange coalesces two consecutive changes to one path inside a batch. The empty string is
+// "nothing pending" both as input and as the result (a transient path that came and went).
+func MergeChange(previous, next ahptypes.ResourceChangeType) ahptypes.ResourceChangeType {
+	switch previous {
+	case "":
+		return next
+	case ahptypes.ResourceChangeTypeAdded:
+		if next == ahptypes.ResourceChangeTypeDeleted {
+			return ""
+		}
+		return ahptypes.ResourceChangeTypeAdded
+	case ahptypes.ResourceChangeTypeDeleted:
+		if next == ahptypes.ResourceChangeTypeDeleted {
+			return ahptypes.ResourceChangeTypeDeleted
+		}
+		return ahptypes.ResourceChangeTypeUpdated
+	}
+	if next == ahptypes.ResourceChangeTypeDeleted {
+		return ahptypes.ResourceChangeTypeDeleted
+	}
+	return ahptypes.ResourceChangeTypeUpdated
+}

package/extensions/ahp/internal/svc/watchpolicy_test.go

@@ -0,0 +1,151 @@
+package svc
+
+import (
+	"fmt"
+	"path/filepath"
+	"testing"
+
+	"github.com/MichaelKinsy/pigpen/ahp/internal/twin"
+	ahptypes "github.com/microsoft/agent-host-protocol/clients/go/ahptypes"
+)
+
+// Twins of upstream test/resource-watch-policy.test.ts: deterministic, no OS events or clocks.
+
+const (
+	cAdded   = ahptypes.ResourceChangeTypeAdded
+	cUpdated = ahptypes.ResourceChangeTypeUpdated
+	cDeleted = ahptypes.ResourceChangeTypeDeleted
+)
+
+func TestWatchPathScopeAndFilters(t *testing.T) {
+	twin.Run(t, "resource-watch-policy", "normalizes descendants and rejects siblings and prefix lookalikes", func(t *testing.T) {
+		root, _ := filepath.Abs("workspace")
+		if rel, ok := RelativeWatchPath(root, root); !ok || rel != "" {
+			t.Fatalf("root: %q %v", rel, ok)
+		}
+		if rel, ok := RelativeWatchPath(root, filepath.Join(root, "nested/../file.txt")); !ok || rel != "file.txt" {
+			t.Fatalf("%q %v", rel, ok)
+		}
+		if rel, ok := RelativeWatchPath(root, filepath.Join(root, "nested/file.txt")); !ok || rel != "nested/file.txt" {
+			t.Fatalf("%q %v", rel, ok)
+		}
+		for _, path := range []string{filepath.Join(root, ".."), filepath.Join(root, "../sibling/file.txt"), root + "-other/file.txt"} {
+			if rel, ok := RelativeWatchPath(root, path); ok {
+				t.Errorf("%s must be out of scope, got %q", path, rel)
+			}
+		}
+	})
+
+	twin.Run(t, "resource-watch-policy", "keeps the watched root visible regardless of filters", func(t *testing.T) {
+		if IsExcluded("", []string{"**"}) {
+			t.Error("the root must never be excluded")
+		}
+		if !MatchesPatterns("", []string{"*.md"}, []string{"**"}) {
+			t.Error("the root must always match")
+		}
+	})
+
+	twin.Run(t, "resource-watch-policy", "applies include alternatives and exclude precedence to every path", func(t *testing.T) {
+		cases := []struct {
+			path             string
+			includes, exclud []string
+			want             bool
+		}{
+			{"file.txt", nil, nil, true},
+			{"nested/file.md", []string{"**/*.md"}, nil, true},
+			{"nested/file.txt", []string{"**/*.md"}, nil, false},
+			{"file.ts", []string{"**/*.md", "**/*.ts"}, nil, true},
+			{"nested/file.md", []string{"**/*.md"}, []string{"nested/**"}, false},
+			{"node_modules/pkg/index.js", nil, []string{"**/node_modules/**"}, false},
+			{"nested/node_modules/pkg/index.js", nil, []string{"**/node_modules/**"}, false},
+			{"node_modules", nil, []string{"**/node_modules/**"}, true},
+			{".git/config", nil, []string{"**/.git/**"}, false},
+			{"src/.hidden.ts", []string{"**/*.ts"}, nil, false},
+			{"src/.hidden.ts", []string{"**/.*.ts"}, nil, true},
+		}
+		for _, c := range cases {
+			if got := MatchesPatterns(c.path, c.includes, c.exclud); got != c.want {
+				t.Errorf("%s includes=%v excludes=%v: got %v, want %v", c.path, c.includes, c.exclud, got, c.want)
+			}
+		}
+	})
+
+	twin.Run(t, "resource-watch-policy", "does not prune a directory just because its children alone match the include filter", func(t *testing.T) {
+		if MatchesPatterns("src", []string{"**/*.ts"}, nil) {
+			t.Error("src alone does not match **/*.ts")
+		}
+		if IsExcluded("src", nil) {
+			t.Error("nothing is excluded without patterns")
+		}
+		if !MatchesPatterns("src/file.ts", []string{"**/*.ts"}, nil) {
+			t.Error("src/file.ts must match")
+		}
+		if !IsExcluded("src/generated", []string{"**/generated"}) {
+			t.Error("src/generated must be excluded")
+		}
+	})
+}
+
+func checkTransitions(t *testing.T, previous ahptypes.ResourceChangeType, expected [3]ahptypes.ResourceChangeType) {
+	t.Helper()
+	for i, change := range []ahptypes.ResourceChangeType{cAdded, cUpdated, cDeleted} {
+		if got := MergeChange(previous, change); got != expected[i] {
+			t.Errorf("%q then %s: got %q, want %q", previous, change, got, expected[i])
+		}
+	}
+}
+
+func TestWatchBatchTransitions(t *testing.T) {
+	twin.Run(t, "resource-watch-policy", "coalesces empty followed by each native event type", func(t *testing.T) {
+		checkTransitions(t, "", [3]ahptypes.ResourceChangeType{cAdded, cUpdated, cDeleted})
+	})
+	twin.Run(t, "resource-watch-policy", "coalesces added followed by each native event type", func(t *testing.T) {
+		checkTransitions(t, cAdded, [3]ahptypes.ResourceChangeType{cAdded, cAdded, ""})
+	})
+	twin.Run(t, "resource-watch-policy", "coalesces updated followed by each native event type", func(t *testing.T) {
+		checkTransitions(t, cUpdated, [3]ahptypes.ResourceChangeType{cUpdated, cUpdated, cDeleted})
+	})
+	twin.Run(t, "resource-watch-policy", "coalesces deleted followed by each native event type", func(t *testing.T) {
+		checkTransitions(t, cDeleted, [3]ahptypes.ResourceChangeType{cUpdated, cUpdated, cDeleted})
+	})
+
+	twin.Run(t, "resource-watch-policy", "handles replacement and transient paths across longer sequences", func(t *testing.T) {
+		cases := []struct {
+			sequence []ahptypes.ResourceChangeType
+			want     ahptypes.ResourceChangeType
+		}{
+			{[]ahptypes.ResourceChangeType{cAdded, cUpdated, cDeleted}, ""},
+			{[]ahptypes.ResourceChangeType{cAdded, cDeleted, cAdded}, cAdded},
+			{[]ahptypes.ResourceChangeType{cDeleted, cAdded, cDeleted}, cDeleted},
+			{[]ahptypes.ResourceChangeType{cDeleted, cAdded, cDeleted, cAdded}, cUpdated},
+			{[]ahptypes.ResourceChangeType{cUpdated, cDeleted, cAdded}, cUpdated},
+		}
+		for _, c := range cases {
+			var got ahptypes.ResourceChangeType
+			for _, change := range c.sequence {
+				got = MergeChange(got, change)
+			}
+			if got != c.want {
+				t.Errorf("%s: got %q, want %q", fmt.Sprint(c.sequence), got, c.want)
+			}
+		}
+	})
+}
+
+func TestGlobMatcher(t *testing.T) {
+	// Additions: the matcher is ours (Node's path.matchesGlob is not in the standard library).
+	cases := []struct {
+		path, pattern string
+		want          bool
+	}{
+		{"a/b.ts", "a/*.ts", true}, {"a/b/c.ts", "a/*.ts", false}, {"a", "a/**", false}, {"a/b", "a/**", true},
+		{"a/x/b", "a/**/b", true}, {"a/b", "a/**/b", true}, {"x.md", "*.{md,txt}", true}, {"x.go", "*.{md,txt}", false},
+		{"file1", "file[0-9]", true}, {"filex", "file[!0-9]", true}, {"file1", "file[!0-9]", false}, {"ab", "a?", true},
+		{".env", "*", false}, {".env", ".*", true}, {"a/.git/x", "a/**", false}, {"a[b", "a[b", true},
+	}
+	for _, c := range cases {
+		if got := matchesGlob(c.path, c.pattern); got != c.want {
+			t.Errorf("matchesGlob(%q, %q) = %v, want %v", c.path, c.pattern, got, c.want)
+		}
+	}
+}