fix: HasStatic 让 Stats 越用越偏；borrowStatic 漏标 scoped

两个都是静态调用那条路上的。

HasStatic 建了 VM 却不记丢弃。Created 在 load 里加（所有建 VM 的路径都走它），
Dropped 在 staticTarget.finish 里加，而 HasStatic 拿到 VM 后直接返回，不走
finish。每调一次 Created-Dropped 就永久 +1——Stats 是导出的观测结构，这个
偏差会直接体现在监控上。改成走同一套记账。

borrowStatic 同样会注入作用域扩展，却不设 vm.scoped。release 靠这个标志拒绝
把带扩展的 VM 放回池子，漏标就是跨调用泄漏。今天不出事只是因为
staticTarget.finish 永远丢弃——同一个约束靠两套机制守，以后有人把静态 VM
接进 release 就会漏。

测试：
  - Stats 那条断言「在飞的 VM 数」调用前后不变
  - scoped 那条是**内部测试**，直接断言标志位。行为测试盖不住它——borrowStatic
    那条路今天靠 finish 兜底，从外面看不出漏标
  两条都做了破坏性验证，摘掉修复会红。

顺带把 WithTimeout 的文档补上一句：要新建 VM 的路径上是顶层和函数调用两段
各自计时，墙钟上限是 2×d。行为不改——两段各自计时是合理的，缺的只是说明。

engine_option.go

@@ -30,8 +30,12 @@ func WithGlobal(name string, value any) Option {
 	return func(e *Engine) { e.globals[name] = value }
 }
 
-// WithTimeout 设置单次调用的时限，超时后脚本会被强制中断，调用方拿到 KindTimeout 错误。
+// WithTimeout 设置单次调用的时限，默认 DefaultTimeout。超时会中断脚本执行
-// 传 0 表示不限时——只在明确知道脚本可信时才这么做。
+// （goja 的 Interrupt），调用方拿到包了 ErrTimeout 的错误。
+//
+// 注意「单次调用」在**要新建 VM** 的路径上是两段各自计时：先给顶层代码一段，
+// 再给函数调用一段，所以墙钟上限是 2×d。走 VM 池命中时没有这个问题——顶层
+// 早就跑过了。要卡死总时长，用带 deadline 的 ctx。
 func WithTimeout(d time.Duration) Option {
 	return func(e *Engine) { e.timeout = d }
 }

scope_pool_test.go

@@ -170,3 +170,52 @@ func TestScopePool_并发不串(t *testing.T) {
 		t.Errorf("%d 次出错:\n%s", len(bad), strings.Join(bad, "\n"))
 	}
 }
+
+// 取 VM 的每一条路径，带作用域时都必须把 scoped 标上。
+//
+// scoped 决定 release 会不会把 VM 放回池子。漏标的后果是**跨调用泄漏作用域扩展**：
+// 下一个不带作用域的调用会看见上一个作用域的 store。
+//
+// 这条用内部测试直接断言标志位，而不是测「有没有漏」——borrowStatic 那条路今天
+// 靠 staticTarget.finish 永远丢弃兜底，行为上看不出漏标，等于同一个约束靠两套
+// 机制守。标志位本身才是唯一的真相。
+func TestVM_每条取VM的路径都标了scoped(t *testing.T) {
+	e, err := New(WithLogger(nil))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer e.Close()
+
+	s, err := e.Compile("c.ts", `export default class C { static S() { return 1 } Run() { return 1 } }`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	scoped := WithScope(context.Background(), ScopeKey("k"))
+	plain := context.Background()
+
+	for _, c := range []struct {
+		name string
+		get  func(ctx context.Context) (*vmHandle, error)
+	}{
+		{"borrow（池化路径）", s.borrow},
+		{"borrowStatic（静态路径）", s.borrowStatic},
+	} {
+		vm, err := c.get(scoped)
+		if err != nil {
+			t.Fatalf("%s: %v", c.name, err)
+		}
+		if !vm.scoped {
+			t.Errorf("%s 在有作用域时没标 scoped——这个 VM 会被放回池子，"+
+				"把作用域的扩展漏给下一个调用", c.name)
+		}
+
+		vm, err = c.get(plain)
+		if err != nil {
+			t.Fatalf("%s（无作用域）: %v", c.name, err)
+		}
+		if vm.scoped {
+			t.Errorf("%s 没有作用域却标了 scoped——白白丢弃可复用的 VM", c.name)
+		}
+	}
+}

static.go

@@ -50,6 +50,12 @@ func (s *Script) HasStatic(fn string) bool {
 	if err != nil {
 		return false
 	}
+	// 建了 VM 就得记一笔丢弃，走跟 CallStatic 同一套记账。漏掉的话每调一次
+	// Stats().Created - Dropped 就永久 +1
+	defer staticTarget{s}.finish(vm, true)
+
+	// ctor != nil 排除 lookup 的全局兜底分支：静态方法必须挂在 class 上，
+	// 脚本导出的不是 class 时 lookup 可能在全局里找到同名函数
 	_, _, _, ok := vm.lookup(fn)
 	return ok && vm.ctor != nil
 }
@@ -82,5 +88,14 @@ func (s *Script) borrowStatic(ctx context.Context) (*vmHandle, error) {
 	if err != nil {
 		return nil, err
 	}
-	return s.load(ctx, rt, nil, true)
+
+	vm, err := s.load(ctx, rt, nil, true)
+	if err != nil {
+		return nil, err
+	}
+	// 带作用域的 VM 装着那个作用域的扩展，绝不能回池。今天 staticTarget.finish
+	// 永远丢弃，标不标都不漏；但同一个约束不该靠两套机制守——以后有人把静态 VM
+	// 接进 release，漏标就是一次跨请求泄漏
+	vm.scoped = extra != nil
+	return vm, nil
 }

static_test.go

@@ -7,6 +7,7 @@ import (
 	"testing"
 
 	"git.fsdpf.net/go/jscriptx"
+	"git.fsdpf.net/go/jscriptx/internal/testext"
 )
 
 // ctorSpy 记录 constructor 有没有被跑过。
@@ -227,3 +228,87 @@ func TestStatic_非class脚本(t *testing.T) {
 		t.Errorf("该报 ErrFuncNotFound: %v", err)
 	}
 }
+
+// HasStatic 建了 VM 就得记一笔丢弃，否则 Stats 会越用越偏。
+//
+// Created 在 load 里加（所有建 VM 的路径都走它），Dropped 在 staticTarget.finish
+// 里加。HasStatic 不走 finish，漏掉的话每调一次 Created-Dropped 就永久 +1——
+// Stats 是导出的观测结构，这个偏差会直接体现在监控上。
+func TestStatic_HasStatic不让Stats跑偏(t *testing.T) {
+	e, err := jscriptx.New(jscriptx.WithLogger(nil))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer e.Close()
+
+	s, err := e.Compile("c.ts", `
+		export default class C {
+			static Startup() { return 1 }
+			Run() { return 2 }
+		}`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	before := s.Stats()
+	inFlight := before.Created - before.Dropped - int64(before.Pooled)
+
+	for range 5 {
+		if !s.HasStatic("Startup") {
+			t.Fatal("该找得到静态方法")
+		}
+	}
+
+	after := s.Stats()
+	if got := after.Created - after.Dropped - int64(after.Pooled); got != inFlight {
+		t.Errorf("调了 5 次 HasStatic 之后在飞的 VM 数变成 %d，本该还是 %d\n"+
+			"（Created %d→%d，Dropped %d→%d）——HasStatic 建了 VM 却没记丢弃",
+			got, inFlight, before.Created, after.Created, before.Dropped, after.Dropped)
+	}
+}
+
+// 带作用域时，静态调用拿到的 VM 必须标成 scoped。
+//
+// scoped 的 VM 带着某个作用域的扩展，回池就会漏给下一个调用。borrow 那条路径
+// 设了这个标志，borrowStatic 同样注入作用域扩展却没设——今天不出事只是因为
+// staticTarget.finish 永远丢弃，等于同一个约束靠两套机制守。
+func TestStatic_作用域VM要标记为不可回池(t *testing.T) {
+	e, err := jscriptx.New(jscriptx.WithLogger(nil))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer e.Close()
+
+	s, err := e.Compile("c.ts", `
+		export default class C {
+			static Startup() { return typeof store }
+		}`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	st := testext.New()
+	ctx := jscriptx.WithScope(context.Background(), jscriptx.ScopeExtensions(st))
+
+	// 先在作用域下跑一次静态方法——这次会建一个带扩展的 VM
+	got, err := s.CallStatic(ctx, "Startup")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != "object" {
+		t.Fatalf("作用域扩展没进去: %#v", got)
+	}
+
+	// 那个 VM 绝不能回池：池里但凡有一个，下一个**无作用域**的调用就会看见 store
+	if p := s.Stats().Pooled; p != 0 {
+		t.Fatalf("作用域 VM 回池了（池里有 %d 个），下一个调用会漏到别人的扩展", p)
+	}
+
+	leak, err := s.CallStatic(context.Background(), "Startup")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if leak != "undefined" {
+		t.Errorf("无作用域的调用看见了 store（%#v）——上一次的作用域漏过来了", leak)
+	}
+}