@dougongjs/reactive 0.0.2 → 0.1.0

package/README.md

@@ -1,12 +1,87 @@
 # @dougongjs/reactive
 
-零依赖的响应式原语：`signal` / `computed` / `batch` / `observe`。
+[简体中文](#简体中文) · [English](#english)
 
-与 `@dougongjs/core` 互不依赖——`observe()` 是一个作用在结构化 `ObservationOwner` 上的自由函数，因此可以驱动 Core 的 Lifetime，而 Core 不需要知道它存在。
+---
 
-- 文档站：https://tangerg.github.io/dougong/
-- 仓库：https://github.com/Tangerg/dougong
+## 简体中文
 
-> 早期开发阶段（0.0.x），当前不承诺向后兼容。需要 Node.js >= 22 或等价的 ES2024 宿主。
+**零依赖**的响应式原语：`signal` / `computed` / `batch` / `observe`。
+
+```sh
+npm install @dougongjs/reactive
+```
+
+```ts
+import { signal, computed, batch, observe } from "@dougongjs/reactive"
+
+const count = signal(0)
+const double = computed(() => count.get() * 2)
+
+batch(() => count.set(21))
+double.get() // 42
+```
+
+`computed` 是惰性的，依赖动态追踪。`batch` 按订阅身份合并回调内的重复通知。三者都拒绝异步回调——同步追踪和批次边界不能跨越 `await`，与其产生静默的错误结果，不如立刻抛错。
+
+### observe：把值的变化编译成资源的重建
+
+```ts
+observe(owner, source, (value, lifetime) => {
+  const socket = new WebSocket(value)
+  lifetime.cleanup(() => socket.close())
+})
+```
+
+每次 `source` 变化：先释放上一个 `lifetime`，再用新值建一个新的。
+
+`observe()` 与 `@dougongjs/core` **互不依赖**——它是一个作用在结构化 `ObservationOwner`（提供 `cleanup` / `lifetime` / `spawn`）上的自由函数，所以能驱动 Core 的 Lifetime，而 Core 不需要知道它存在。插件的 `ctx` 恰好满足这个形状。
+
+`source` 只需满足结构化的 `Readable<T>`（`get()` + `subscribe()`）——Signal、Core 的 `ContributionView`、诊断视图，甚至你自己写的对象都可以。
+
+---
+
+## English
+
+**Zero-dependency** reactive primitives: `signal` / `computed` / `batch` / `observe`.
+
+```sh
+npm install @dougongjs/reactive
+```
+
+```ts
+import { signal, computed, batch, observe } from "@dougongjs/reactive"
+
+const count = signal(0)
+const double = computed(() => count.get() * 2)
+
+batch(() => count.set(21))
+double.get() // 42
+```
+
+`computed` is lazy with dynamic dependency tracking. `batch` coalesces repeated notifications per subscription identity. All three reject asynchronous callbacks — synchronous tracking and batch boundaries cannot survive an `await`, and throwing immediately beats producing a silently wrong result.
+
+### observe: compiling value change into resource rebuild
+
+```ts
+observe(owner, source, (value, lifetime) => {
+  const socket = new WebSocket(value)
+  lifetime.cleanup(() => socket.close())
+})
+```
+
+On each change to `source`: release the previous `lifetime`, then build a new one from the new value.
+
+`observe()` and `@dougongjs/core` are **mutually independent** — it is a free function over a structural `ObservationOwner` (anything providing `cleanup` / `lifetime` / `spawn`), so it can drive Core Lifetimes without Core knowing it exists. A plugin's `ctx` happens to satisfy that shape.
+
+`source` need only satisfy the structural `Readable<T>` (`get()` + `subscribe()`) — a signal, Core's `ContributionView`, a diagnostics view, or your own object.
+
+---
+
+- 文档站 / Documentation: https://tangerg.github.io/dougong/
+- 仓库 / Repository: https://github.com/Tangerg/dougong
+
+> 早期开发阶段（0.0.x），当前不承诺向后兼容。需要 Node.js ≥ 22 或等价的 ES2024 运行时。
+> Early development (0.0.x); no backward-compatibility promises yet. Requires Node.js ≥ 22 or an equivalent ES2024 runtime.
 
 MIT

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { Readable } from './protocol';
-export type { Disposable, Readable } from './protocol';
+export type { AsyncDisposable, Disposable, Readable } from './protocol';
 declare const dougongSignal: unique symbol;
 /** A reactive node created by Dougong and safe to compose with computed(). */
 export interface ReadonlySignal<T> extends Readable<T> {

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,QAAQ,EAAE,MAAM,YAAY,CAAC;AAGvD,YAAY,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEvD,OAAO,CAAC,MAAM,aAAa,EAAE,OAAO,MAAM,CAAC;AAE3C,8EAA8E;AAC9E,MAAM,WAAW,cAAc,CAAC,CAAC,CAAE,SAAQ,QAAQ,CAAC,CAAC,CAAC;IACpD,QAAQ,CAAC,CAAC,aAAa,CAAC,EAAE,IAAI,CAAC;CAChC;AAED,MAAM,WAAW,MAAM,CAAC,CAAC,CAAE,SAAQ,cAAc,CAAC,CAAC,CAAC;IAClD,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;CACrB;AAED,OAAO,EACL,OAAO,EACP,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,QAAQ,GACd,MAAM,WAAW,CAAC;AAyFnB,wBAAgB,KAAK,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC,CA4B7C;AAED,wBAAgB,MAAM,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAkCpD;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAGjE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,QAAQ,EAAE,MAAM,YAAY,CAAC;AAGvD,YAAY,EAAE,eAAe,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAExE,OAAO,CAAC,MAAM,aAAa,EAAE,OAAO,MAAM,CAAC;AAE3C,8EAA8E;AAC9E,MAAM,WAAW,cAAc,CAAC,CAAC,CAAE,SAAQ,QAAQ,CAAC,CAAC,CAAC;IACpD,QAAQ,CAAC,CAAC,aAAa,CAAC,EAAE,IAAI,CAAC;CAChC;AAED,MAAM,WAAW,MAAM,CAAC,CAAC,CAAE,SAAQ,cAAc,CAAC,CAAC,CAAC;IAClD,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;CACrB;AAED,OAAO,EACL,OAAO,EACP,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,QAAQ,GACd,MAAM,WAAW,CAAC;AA8FnB,wBAAgB,KAAK,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC,CA4B7C;AAED,wBAAgB,MAAM,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAsCpD;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAGjE"}

package/dist/index.js

@@ -1,218 +1,237 @@
-function d(e, t) {
-  if (b(e))
-    throw Promise.resolve(e).catch(() => {
-    }), new TypeError(t);
+function d(t, e) {
+  if (b(t))
+    throw Promise.resolve(t).catch(() => {
+    }), new TypeError(e);
 }
-function b(e) {
-  return e === null || typeof e != "object" && typeof e != "function" ? !1 : typeof e.then == "function";
+function b(t) {
+  return t === null || typeof t != "object" && typeof t != "function" ? !1 : typeof t.then == "function";
 }
-class E {
+class k {
+  #e;
+  #s;
   #i;
+  #n = { present: !1 };
+  #r = !1;
   #t;
-  #r;
-  #h;
-  #n;
-  #e = { present: !1 };
-  #o = !1;
-  #s = "active";
-  #a;
+  #o;
   #c;
-  #u;
-  constructor(t, s, i) {
-    this.#i = t, this.#t = s, this.#r = i;
+  constructor(e, s, i) {
+    this.#e = { phase: "active", binding: { owner: e, source: s, observer: i } };
   }
   start() {
-    const t = this.#t.get(), s = this.#i.lifetime("observation");
-    l(s), this.#n = s;
-    const i = this.#t.subscribe(() => this.#w());
-    v(i, "Readable.subscribe()"), this.#h = i, this.#l(t, s), this.#e = { present: !0, value: t };
-    const n = this.#i.spawn((r) => this.#y(r));
-    T(n), this.#a = n, n.result.then(
-      () => this.#v(n),
-      () => this.#v(n)
+    const { owner: e, source: s } = this.#w(), i = s.get(), r = e.lifetime("observation");
+    l(r), this.#i = r;
+    const n = s.subscribe(() => this.#p());
+    E(n, "Readable.subscribe()"), this.#s = n, this.#l(i, r), this.#n = { present: !0, value: i };
+    const o = e.spawn((c) => this.#h(c));
+    S(o), this.#t = o, o.result.then(
+      () => this.#v(o),
+      () => this.#v(o)
     );
   }
   dispose() {
-    if (this.#u) return this.#u;
-    const t = Promise.withResolvers();
-    return this.#u = t.promise, this.#s = "disposed", this.#c?.(), this.#f().then(t.resolve, t.reject), t.promise;
+    if (this.#c) return this.#c;
+    const e = Promise.withResolvers();
+    return this.#c = e.promise, this.#y("disposed"), this.#o?.(), this.#f().then(e.resolve, e.reject), e.promise;
   }
   async #f() {
-    const t = [];
-    if (await c(this.#b(), t), await c(this.#O(), t), await c(this.#p(), t), t.length === 1) throw t[0];
-    if (t.length > 1) throw new AggregateError(t, "Observation cleanup failed");
+    const e = [];
+    if (await a(this.#b(), e), await a(this.#m(), e), await a(this.#u(), e), e.length === 1) throw e[0];
+    if (e.length > 1) throw new AggregateError(e, "Observation cleanup failed");
   }
-  #w() {
-    this.#s === "active" && (this.#o = !0, this.#c?.());
+  #p() {
+    this.#e.phase === "active" && (this.#r = !0, this.#o?.());
   }
-  async #y(t) {
+  async #h(e) {
     try {
-      for (; this.#s === "active" && !t.aborted; )
-        for (await this.#m(t); this.#s === "active" && !t.aborted && this.#o; )
-          this.#o = !1, await this.#g();
+      for (; this.#e.phase === "active" && !e.aborted; )
+        for (await this.#a(e); this.#e.phase === "active" && !e.aborted && this.#r; )
+          this.#r = !1, await this.#g();
     } catch (s) {
-      if (this.#s === "stopped") throw s;
+      if (this.#e.phase !== "active") throw s;
       await this.#d([s], "Observation stopped after a replacement failed");
     }
   }
-  #m(t) {
-    return this.#o || this.#s !== "active" || t.aborted ? Promise.resolve() : new Promise((s) => {
+  #a(e) {
+    return this.#r || this.#e.phase !== "active" || e.aborted ? Promise.resolve() : new Promise((s) => {
       const i = () => {
-        t.removeEventListener("abort", i), this.#c === i && (this.#c = void 0), s();
+        e.removeEventListener("abort", i), this.#o === i && (this.#o = void 0), s();
       };
-      this.#c = i, t.addEventListener("abort", i, { once: !0 }), (this.#o || this.#s !== "active" || t.aborted) && i();
+      this.#o = i, e.addEventListener("abort", i, { once: !0 }), (this.#r || this.#e.phase !== "active" || e.aborted) && i();
     });
   }
   async #g() {
-    if (this.#s !== "active") return;
-    const t = this.#t.get();
-    if (this.#e.present && Object.is(t, this.#e.value)) return;
-    const s = this.#p();
+    if (this.#e.phase !== "active") return;
+    const e = this.#e.binding.source.get();
+    if (this.#n.present && Object.is(e, this.#n.value)) return;
+    const s = this.#u();
     if (s)
       try {
         await s.dispose();
-      } catch (n) {
+      } catch (r) {
+        if (this.#e.phase !== "active") throw r;
         return this.#d(
-          [n],
+          [r],
           "Observation stopped because the previous lifetime could not be disposed"
         );
       }
-    if (this.#e = { present: !1 }, this.#s !== "active") return;
-    const i = this.#i.lifetime("observation");
-    l(i);
+    if (this.#n = { present: !1 }, this.#e.phase !== "active") return;
+    const i = this.#e.binding.owner.lifetime("observation");
+    l(i), this.#i = i;
     try {
-      this.#l(t, i);
-    } catch (n) {
+      this.#l(e, i);
+    } catch (r) {
+      const n = this.#u();
       try {
-        await i.dispose();
-      } catch (r) {
+        n && await n.dispose();
+      } catch (o) {
+        if (this.#e.phase !== "active")
+          throw new AggregateError(
+            [r, o],
+            "Observation callback failed and its resources could not be cleaned up"
+          );
         return this.#d(
-          [n, r],
+          [r, o],
           "Observation callback failed and its resources could not be cleaned up"
         );
       }
-      throw n;
+      throw r;
     }
-    this.#n = i, this.#e = { present: !0, value: t };
+    this.#e.phase === "active" && (this.#n = { present: !0, value: e });
   }
-  #l(t, s) {
-    const i = this.#r(t, s);
+  #l(e, s) {
+    const i = this.#w().observer(e, s);
     d(i, "Observers must be synchronous; use lifetime.spawn() for async work");
   }
   #b() {
-    const t = this.#h;
-    return this.#h = void 0, t;
+    const e = this.#s;
+    return this.#s = void 0, e;
   }
-  #p() {
-    const t = this.#n;
-    return this.#n = void 0, t;
+  #u() {
+    const e = this.#i;
+    return this.#i = void 0, e;
   }
-  #O() {
-    const t = this.#a;
-    return this.#a = void 0, t;
+  #m() {
+    const e = this.#t;
+    return this.#t = void 0, e;
   }
-  #v(t) {
-    this.#a === t && (this.#a = void 0);
+  #v(e) {
+    this.#t === e && (this.#t = void 0);
   }
-  async #d(t, s) {
-    throw this.#s = "stopped", this.#c?.(), await c(this.#b(), t), await c(this.#p(), t), t.length === 1 ? t[0] : new AggregateError(t, s);
+  async #d(e, s) {
+    throw this.#y("stopped"), this.#o?.(), await a(this.#b(), e), await a(this.#u(), e), e.length === 1 ? e[0] : new AggregateError(e, s);
+  }
+  #w() {
+    const e = this.#e;
+    if (e.phase !== "active") throw new Error("Observation is not active");
+    return e.binding;
+  }
+  #y(e) {
+    this.#e = { phase: e }, this.#n = { present: !1 }, this.#r = !1;
   }
 }
-function j(e, t, s) {
-  if (!t || typeof t.get != "function" || typeof t.subscribe != "function")
+function A(t, e, s) {
+  if (!e || typeof e.get != "function" || typeof e.subscribe != "function")
     throw new TypeError("observe() expects a readable source");
   if (typeof s != "function") throw new TypeError("Observer must be a function");
-  if (!e || typeof e.cleanup != "function" || typeof e.lifetime != "function" || typeof e.spawn != "function")
+  if (!t || typeof t.cleanup != "function" || typeof t.lifetime != "function" || typeof t.spawn != "function")
     throw new TypeError("observe() expects an observation owner");
-  const i = new E(e, t, s), n = e.cleanup(() => i.dispose());
-  v(n, "ObservationOwner.cleanup()");
+  const i = new k(t, e, s), r = t.cleanup(() => i.dispose());
+  T(r, "ObservationOwner.cleanup()");
   try {
-    return i.start(), n;
-  } catch (r) {
+    return i.start(), r;
+  } catch (n) {
     throw i.dispose().catch(() => {
-    }), r;
+    }), n;
   }
 }
-function v(e, t) {
-  if (!e || typeof e.dispose != "function")
-    throw new TypeError(`${t} must return a Disposable`);
+function E(t, e) {
+  if (!t || typeof t.dispose != "function" || typeof t[Symbol.dispose] != "function")
+    throw new TypeError(`${e} must return a Disposable`);
 }
-function l(e) {
-  if (!e || typeof e.dispose != "function" || typeof e.cleanup != "function" || typeof e.lifetime != "function" || typeof e.spawn != "function")
+function T(t, e) {
+  if (!t || typeof t.dispose != "function" || typeof t[Symbol.asyncDispose] != "function")
+    throw new TypeError(`${e} must return an AsyncDisposable`);
+}
+function l(t) {
+  if (!t || typeof t.dispose != "function" || typeof t[Symbol.asyncDispose] != "function" || typeof t.cleanup != "function" || typeof t.lifetime != "function" || typeof t.spawn != "function")
     throw new TypeError("ObservationOwner.lifetime() must return an ObservationLifetime");
 }
-function T(e) {
-  if (!e || typeof e.dispose != "function" || !b(e.result))
+function S(t) {
+  if (!t || typeof t.dispose != "function" || typeof t[Symbol.asyncDispose] != "function" || !b(t.result))
     throw new TypeError("ObservationOwner.spawn() must return an ObservationTask");
 }
-async function c(e, t) {
-  if (e)
+async function a(t, e) {
+  if (t)
     try {
-      await e.dispose();
+      await t.dispose();
     } catch (s) {
-      t.push(s);
+      e.push(s);
     }
 }
-let u = 0, a, f;
+let u = 0, h, f;
 const p = /* @__PURE__ */ new WeakMap();
-function w(e) {
-  return new S(e);
+function v(t) {
+  return new D(t);
 }
-class S {
-  #i;
-  constructor(t) {
-    this.#i = t, Object.freeze(this);
+class D {
+  #e;
+  constructor(e) {
+    this.#e = e, Object.freeze(this);
   }
   dispose() {
-    const t = this.#i;
-    this.#i = void 0, t?.();
+    const e = this.#e;
+    this.#e = void 0, e?.();
   }
   [Symbol.dispose]() {
     this.dispose();
   }
 }
 function z() {
-  const e = [];
-  for (; a?.size; ) {
-    const t = a;
-    a = /* @__PURE__ */ new Set(), m(t, e);
+  const t = [];
+  for (; h?.size; ) {
+    const e = h;
+    h = /* @__PURE__ */ new Set(), y(e, t);
   }
-  a = void 0, g(e);
+  h = void 0, g(t);
 }
-function y(e) {
+function w(t) {
   if (u) {
-    const s = a ??= /* @__PURE__ */ new Set();
-    for (const i of e) s.add(i);
+    const s = h ??= /* @__PURE__ */ new Set();
+    for (const i of t) s.add(i);
     return;
   }
-  const t = [];
-  m([...e], t), g(t);
+  const e = [];
+  y(t, e), g(e);
 }
-function m(e, t) {
-  for (const s of e)
-    try {
-      s();
-    } catch (i) {
-      t.push(i);
-    }
+function y(t, e) {
+  for (const s of t) {
+    const i = s.listener;
+    if (i)
+      try {
+        i();
+      } catch (r) {
+        e.push(r);
+      }
+  }
 }
-function g(e) {
-  if (e.length === 1) throw e[0];
-  if (e.length > 1)
-    throw new AggregateError(e, "Reactive subscribers failed");
+function g(t) {
+  if (t.length === 1) throw t[0];
+  if (t.length > 1)
+    throw new AggregateError(t, "Reactive subscribers failed");
 }
-function O(e) {
-  f?.(e);
+function m(t) {
+  f?.(t);
 }
-function C(e) {
-  if (typeof e != "function") throw new TypeError("batch() expects a function");
+function C(t) {
+  if (typeof t != "function") throw new TypeError("batch() expects a function");
   u++;
-  let t;
+  let e;
   try {
-    const s = e();
-    d(s, "Reactive batches must be synchronous"), t = { ok: !0, value: s };
+    const s = t();
+    d(s, "Reactive batches must be synchronous"), e = { ok: !0, value: s };
   } catch (s) {
-    t = { ok: !1, error: s };
+    e = { ok: !1, error: s };
   } finally {
     u--;
   }
@@ -220,121 +239,125 @@ function C(e) {
     try {
       z();
     } catch (s) {
-      t = t.ok ? { ok: !1, error: s } : { ok: !1, error: new AggregateError([t.error, s], "Reactive batch failed") };
+      e = e.ok ? { ok: !1, error: s } : { ok: !1, error: new AggregateError([e.error, s], "Reactive batch failed") };
     }
-  if (!t.ok) throw t.error;
-  return t.value;
+  if (!e.ok) throw e.error;
+  return e.value;
 }
-function D(e) {
-  let t = e, s = 0;
-  const i = /* @__PURE__ */ new Set(), n = {
+function L(t) {
+  let e = t, s = 0;
+  const i = /* @__PURE__ */ new Set(), r = {
     get() {
-      return O(n), t;
+      return m(r), e;
     },
-    set(r) {
-      Object.is(t, r) || (t = r, s++, y(i));
+    set(n) {
+      Object.is(e, n) || (e = n, s++, w(i));
     },
-    subscribe(r) {
-      return k(r), i.add(r), w(() => i.delete(r));
+    subscribe(n) {
+      O(n);
+      const o = { listener: n };
+      return i.add(o), v(() => {
+        o.listener = void 0, i.delete(o);
+      });
     }
   };
-  return p.set(n, {
+  return p.set(r, {
     get version() {
       return s;
     },
     refresh() {
     }
-  }), Object.freeze(n);
+  }), Object.freeze(r);
 }
-function R(e) {
-  if (typeof e != "function") throw new TypeError("computed() expects a function");
-  return new L(e).view;
+function R(t) {
+  if (typeof t != "function") throw new TypeError("computed() expects a function");
+  return new j(t).view;
 }
-class L {
-  #i;
-  #t = /* @__PURE__ */ new Set();
-  #r = /* @__PURE__ */ new Map();
-  #h = { phase: "uninitialized" };
-  #n = !1;
-  #e = !0;
+class j {
+  #e;
+  #s = /* @__PURE__ */ new Set();
+  #i = /* @__PURE__ */ new Map();
+  #n = { phase: "uninitialized" };
+  #r = !1;
+  #t = !0;
   #o = 0;
   view;
-  constructor(t) {
-    this.#i = t, this.view = Object.freeze({
-      get: () => this.#s(),
-      subscribe: (s) => this.#a(s)
+  constructor(e) {
+    this.#e = e, this.view = Object.freeze({
+      get: () => this.#c(),
+      subscribe: (s) => this.#f(s)
     }), p.set(this.view, this);
   }
   get version() {
     return this.#o;
   }
   refresh() {
-    this.#f();
+    this.#a();
   }
-  #s() {
-    return O(this.view), this.#f();
+  #c() {
+    return m(this.view), this.#a();
   }
-  #a(t) {
-    k(t);
-    const s = this.#t.size === 0;
-    if (this.#t.add(t), s)
+  #f(e) {
+    O(e);
+    const s = { listener: e }, i = this.#s.size === 0;
+    if (this.#s.add(s), i)
       try {
-        this.#e = !0, this.#f();
-      } catch (i) {
-        throw this.#t.delete(t), this.#t.size || this.#u(), i;
+        this.#t = !0, this.#a();
+      } catch (r) {
+        throw this.#s.delete(s), this.#s.size || this.#h(), r;
       }
-    return w(() => {
-      this.#t.delete(t), this.#t.size || this.#u();
+    return v(() => {
+      s.listener = void 0, this.#s.delete(s), this.#s.size || this.#h();
     });
   }
-  #c = () => {
-    this.#e || (this.#e = !0, y(this.#t));
+  #p = () => {
+    this.#t || (this.#t = !0, w(this.#s));
   };
-  #u() {
-    for (const t of this.#r.values())
-      t.subscription?.dispose(), t.subscription = void 0;
+  #h() {
+    for (const e of this.#i.values())
+      e.subscription?.dispose(), e.subscription = void 0;
   }
-  #f() {
-    const t = this.#h;
-    if (t.phase === "cached" && !this.#e) {
-      for (const r of this.#r.values())
-        if (r.node.refresh(), r.version !== r.node.version) {
-          this.#e = !0;
+  #a() {
+    const e = this.#n;
+    if (e.phase === "cached" && !this.#t) {
+      for (const n of this.#i.values())
+        if (n.node.refresh(), n.version !== n.node.version) {
+          this.#t = !0;
           break;
         }
-      if (!this.#e) return t.value;
+      if (!this.#t) return e.value;
     }
-    if (this.#n) throw new TypeError("Circular computed signal");
+    if (this.#r) throw new TypeError("Circular computed signal");
     const s = /* @__PURE__ */ new Set(), i = f;
-    this.#n = !0, f = (r) => s.add(r);
-    let n;
+    this.#r = !0, f = (n) => s.add(n);
+    let r;
     try {
-      n = this.#i(), d(n, "Computed signal calculations must be synchronous");
+      r = this.#e(), d(r, "Computed signal calculations must be synchronous");
     } finally {
-      f = i, this.#n = !1;
+      f = i, this.#r = !1;
     }
-    for (const [r, o] of this.#r)
-      s.has(r) || (o.subscription?.dispose(), this.#r.delete(r));
-    for (const r of s) {
-      const o = p.get(r);
+    for (const [n, o] of this.#i)
+      s.has(n) || (o.subscription?.dispose(), this.#i.delete(n));
+    for (const n of s) {
+      const o = p.get(n);
       if (!o) continue;
-      const h = this.#r.get(r) ?? {
+      const c = this.#i.get(n) ?? {
         node: o,
         version: o.version,
         subscription: void 0
       };
-      h.version = o.version, this.#t.size && !h.subscription && (h.subscription = r.subscribe(this.#c)), this.#r.set(r, h);
+      c.version = o.version, this.#s.size && !c.subscription && (c.subscription = n.subscribe(this.#p)), this.#i.set(n, c);
     }
-    return (t.phase === "uninitialized" || !Object.is(t.value, n)) && this.#o++, this.#h = { phase: "cached", value: n }, this.#e = !1, n;
+    return (e.phase === "uninitialized" || !Object.is(e.value, r)) && this.#o++, this.#n = { phase: "cached", value: r }, this.#t = !1, r;
   }
 }
-function k(e) {
-  if (typeof e != "function")
+function O(t) {
+  if (typeof t != "function")
     throw new TypeError("Signal subscriber must be a function");
 }
 export {
   C as batch,
   R as computed,
-  j as observe,
-  D as signal
+  A as observe,
+  L as signal
 };

package/dist/observe.d.ts

@@ -1,14 +1,14 @@
-import { Disposable, Readable } from './protocol';
-export interface ObservationTask<T = void> extends Disposable {
+import { AsyncDisposable, Readable } from './protocol';
+export interface ObservationTask<T = void> extends AsyncDisposable {
     readonly result: Promise<T>;
 }
-export interface ObservationLifetime extends Disposable {
-    cleanup(dispose: () => unknown): Disposable;
+export interface ObservationLifetime extends AsyncDisposable {
+    cleanup(dispose: () => unknown): AsyncDisposable;
     lifetime(label: string): ObservationLifetime;
     spawn<T>(task: (signal: AbortSignal) => T | PromiseLike<T>): ObservationTask<T>;
 }
 export interface ObservationOwner<Child extends ObservationLifetime = ObservationLifetime> {
-    cleanup(dispose: () => unknown): Disposable;
+    cleanup(dispose: () => unknown): AsyncDisposable;
     lifetime(label: string): Child;
     spawn<T>(task: (signal: AbortSignal) => T | PromiseLike<T>): ObservationTask<T>;
 }
@@ -17,5 +17,5 @@ export type Observer<T, Child extends ObservationLifetime> = (value: T, lifetime
  * Lifetime-aware synchronization built only from the public source and
  * Lifetime protocols. It is a reactive-layer combinator, not a Core hook.
  */
-export declare function observe<T, Child extends ObservationLifetime>(owner: ObservationOwner<Child>, source: Readable<T>, observer: Observer<T, Child>): Disposable;
+export declare function observe<T, Child extends ObservationLifetime>(owner: ObservationOwner<Child>, source: Readable<T>, observer: Observer<T, Child>): AsyncDisposable;
 //# sourceMappingURL=observe.d.ts.map

package/dist/observe.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"observe.d.ts","sourceRoot":"","sources":["../src/observe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAGvD,MAAM,WAAW,eAAe,CAAC,CAAC,GAAG,IAAI,CAAE,SAAQ,UAAU;IAC3D,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;CAC7B;AAED,MAAM,WAAW,mBAAoB,SAAQ,UAAU;IACrD,OAAO,CAAC,OAAO,EAAE,MAAM,OAAO,GAAG,UAAU,CAAC;IAC5C,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,mBAAmB,CAAC;IAC7C,KAAK,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC;CACjF;AAED,MAAM,WAAW,gBAAgB,CAAC,KAAK,SAAS,mBAAmB,GAAG,mBAAmB;IACvF,OAAO,CAAC,OAAO,EAAE,MAAM,OAAO,GAAG,UAAU,CAAC;IAC5C,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,CAAC;IAC/B,KAAK,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC;CACjF;AAED,MAAM,MAAM,QAAQ,CAAC,CAAC,EAAE,KAAK,SAAS,mBAAmB,IAAI,CAAC,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,KAAK,KAAK,IAAI,CAAC;AA+KjG;;;GAGG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,SAAS,mBAAmB,EAC1D,KAAK,EAAE,gBAAgB,CAAC,KAAK,CAAC,EAC9B,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EACnB,QAAQ,EAAE,QAAQ,CAAC,CAAC,EAAE,KAAK,CAAC,GAC3B,UAAU,CA0BZ"}
+{"version":3,"file":"observe.d.ts","sourceRoot":"","sources":["../src/observe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAc,QAAQ,EAAY,MAAM,YAAY,CAAC;AAGlF,MAAM,WAAW,eAAe,CAAC,CAAC,GAAG,IAAI,CAAE,SAAQ,eAAe;IAChE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;CAC7B;AAED,MAAM,WAAW,mBAAoB,SAAQ,eAAe;IAC1D,OAAO,CAAC,OAAO,EAAE,MAAM,OAAO,GAAG,eAAe,CAAC;IACjD,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,mBAAmB,CAAC;IAC7C,KAAK,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC;CACjF;AAED,MAAM,WAAW,gBAAgB,CAAC,KAAK,SAAS,mBAAmB,GAAG,mBAAmB;IACvF,OAAO,CAAC,OAAO,EAAE,MAAM,OAAO,GAAG,eAAe,CAAC;IACjD,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,CAAC;IAC/B,KAAK,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC;CACjF;AAED,MAAM,MAAM,QAAQ,CAAC,CAAC,EAAE,KAAK,SAAS,mBAAmB,IAAI,CAAC,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,KAAK,KAAK,IAAI,CAAC;AA+MjG;;;GAGG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,SAAS,mBAAmB,EAC1D,KAAK,EAAE,gBAAgB,CAAC,KAAK,CAAC,EAC9B,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EACnB,QAAQ,EAAE,QAAQ,CAAC,CAAC,EAAE,KAAK,CAAC,GAC3B,eAAe,CA0BjB"}

package/dist/protocol.d.ts

@@ -1,9 +1,13 @@
 export interface Disposable {
-    dispose(): void | Promise<void>;
-    [Symbol.dispose]?(): void;
-    [Symbol.asyncDispose]?(): Promise<void>;
+    dispose(): void;
+    [Symbol.dispose](): void;
 }
-/** Structural observable protocol shared by signals, extensions and diagnostics. */
+export interface AsyncDisposable {
+    dispose(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+export type Resource = Disposable | AsyncDisposable;
+/** Structural observable protocol shared by signals, ContributionViews and diagnostics. */
 export interface Readable<T> {
     get(): T;
     subscribe(listener: () => void): Disposable;

package/dist/protocol.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../src/protocol.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,UAAU;IACzB,OAAO,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAChC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,IAAI,CAAC;IAC1B,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACzC;AAED,oFAAoF;AACpF,MAAM,WAAW,QAAQ,CAAC,CAAC;IACzB,GAAG,IAAI,CAAC,CAAC;IACT,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,UAAU,CAAC;CAC7C"}
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../src/protocol.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,UAAU;IACzB,OAAO,IAAI,IAAI,CAAC;IAChB,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC;CAC1B;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACzB,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxC;AAED,MAAM,MAAM,QAAQ,GAAG,UAAU,GAAG,eAAe,CAAC;AAEpD,2FAA2F;AAC3F,MAAM,WAAW,QAAQ,CAAC,CAAC;IACzB,GAAG,IAAI,CAAC,CAAC;IACT,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,UAAU,CAAC;CAC7C"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dougongjs/reactive",
-  "version": "0.0.2",
+  "version": "0.1.0",
   "type": "module",
   "engines": {
     "node": ">=22"