@dougongjs/reactive 0.8.1 → 0.8.2

package/README.md

@@ -19,9 +19,11 @@ const count = signal(0)
 const double = computed(() => count.get() * 2)
 
 batch(() => count.set(21))
-double.get() // 42
+double.get()
 ```
 
+`double.get()` 返回 `42`。
+
 `computed` 是惰性的，依赖动态追踪。`batch` 按订阅身份合并回调内的重复通知。三者都拒绝异步回调——同步追踪和批次边界不能跨越 `await`，与其产生静默的错误结果，不如立刻抛错。
 
 ### observe：把值的变化编译成资源的重建
@@ -56,9 +58,11 @@ const count = signal(0)
 const double = computed(() => count.get() * 2)
 
 batch(() => count.set(21))
-double.get() // 42
+double.get()
 ```
 
+`double.get()` returns `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

package/dist/disposal-runtime.d.ts

@@ -1,9 +1,5 @@
-/** Fails at module load before an unavailable Promise primitive reaches a lifecycle transition. */
 export declare function assertPromiseRuntime(withResolvers: unknown): asserts withResolvers is typeof Promise.withResolvers;
-/** Resolves the conventional protocol key without mutating the ambient Symbol constructor. */
 export declare function resolveDisposalSymbol(native: symbol | undefined, name: "Symbol.dispose" | "Symbol.asyncDispose"): symbol;
-/** Canonical runtime key for Dougong's synchronous disposal protocol. */
 export declare const disposeSymbol: typeof Symbol.dispose;
-/** Canonical runtime key for Dougong's asynchronous disposal protocol. */
 export declare const asyncDisposeSymbol: typeof Symbol.asyncDispose;
 //# sourceMappingURL=disposal-runtime.d.ts.map

package/dist/disposal-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"disposal-runtime.d.ts","sourceRoot":"","sources":["../src/disposal-runtime.ts"],"names":[],"mappings":"AACA,mGAAmG;AACnG,wBAAgB,oBAAoB,CAClC,aAAa,EAAE,OAAO,GACrB,OAAO,CAAC,aAAa,IAAI,OAAO,OAAO,CAAC,aAAa,CAIvD;AAED,8FAA8F;AAC9F,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,IAAI,EAAE,gBAAgB,GAAG,qBAAqB,UAG/C;AAID,yEAAyE;AACzE,eAAO,MAAM,aAAa,EAAE,OAAO,MAAM,CAAC,OAGhB,CAAC;AAC3B,0EAA0E;AAC1E,eAAO,MAAM,kBAAkB,EAAE,OAAO,MAAM,CAAC,YAGhB,CAAC"}
+{"version":3,"file":"disposal-runtime.d.ts","sourceRoot":"","sources":["../src/disposal-runtime.ts"],"names":[],"mappings":"AACA,wBAAgB,oBAAoB,CAClC,aAAa,EAAE,OAAO,GACrB,OAAO,CAAC,aAAa,IAAI,OAAO,OAAO,CAAC,aAAa,CAIvD;AAED,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,IAAI,EAAE,gBAAgB,GAAG,qBAAqB,UAG/C;AAID,eAAO,MAAM,aAAa,EAAE,OAAO,MAAM,CAAC,OAGhB,CAAC;AAC3B,eAAO,MAAM,kBAAkB,EAAE,OAAO,MAAM,CAAC,YAGhB,CAAC"}

package/dist/index.js

@@ -1,40 +1,37 @@
-function R(t) {
-  if (typeof t != "function")
+function D(s) {
+  if (typeof s != "function")
     throw new Error("Unsupported JavaScript runtime: Promise.withResolvers is required");
 }
-function y(t, e) {
-  return t ?? Symbol.for(e);
+function b(s, e) {
+  return s ?? Symbol.for(e);
 }
-R(Promise.withResolvers);
-const m = y(
+D(Promise.withResolvers);
+const w = b(
   Symbol.dispose,
   "Symbol.dispose"
-), g = y(
+), y = b(
   Symbol.asyncDispose,
   "Symbol.asyncDispose"
 );
-function h(t, e) {
-  const s = O(t);
-  if (s)
-    throw s.catch(() => {
+function a(s, e) {
+  const t = m(s);
+  if (t)
+    throw t.catch(() => {
     }), new TypeError(e);
 }
-function O(t) {
-  if (t === null || typeof t != "object" && typeof t != "function") return;
-  const e = t.then;
+function m(s) {
+  if (s === null || typeof s != "object" && typeof s != "function") return;
+  const e = s.then;
   if (typeof e == "function")
     return Promise.resolve().then(
-      () => new Promise((s, i) => Reflect.apply(e, t, [s, i]))
+      () => new Promise((t, i) => Reflect.apply(e, s, [t, i]))
     );
 }
-let f = 0, l = !1;
-const p = /* @__PURE__ */ new Set(), c = /* @__PURE__ */ new Set();
-let a;
-const d = /* @__PURE__ */ new WeakMap();
-function S(t) {
-  return new z(t);
-}
-class z {
+let u = 0, p = !1;
+const f = /* @__PURE__ */ new Set(), o = /* @__PURE__ */ new Set();
+let c;
+const l = /* @__PURE__ */ new WeakMap();
+class g {
   #e;
   constructor(e) {
     this.#e = e, Object.freeze(this);
@@ -43,224 +40,232 @@ class z {
     const e = this.#e;
     this.#e = void 0, e?.();
   }
-  [m]() {
+  [w]() {
     this.dispose();
   }
 }
-function E() {
-  if (l) return;
-  const t = [];
-  l = !0;
+function O() {
+  if (p) return;
+  const s = [];
+  p = !0;
   try {
-    for (; c.size || p.size; ) {
-      const e = c.size ? c : p, s = e.values().next().value;
-      e.delete(s);
-      const i = s.listener;
+    for (; o.size || f.size; ) {
+      const e = o.size ? o : f, t = e.values().next().value;
+      e.delete(t);
+      const i = t.listener;
       if (i)
         try {
-          h(i(), "Signal subscribers must be synchronous");
-        } catch (n) {
-          t.push(n);
+          a(i(), "Signal subscribers must be synchronous");
+        } catch (r) {
+          s.push(r);
         }
     }
   } finally {
-    p.clear(), c.clear(), l = !1;
+    f.clear(), o.clear(), p = !1;
   }
-  P(t);
+  R(s);
 }
-function k(t) {
-  for (const e of t)
-    (e.kind === "dependency" ? c : p).add(e);
-  f || E();
+function S(s) {
+  for (const e of s)
+    (e.kind === "dependency" ? o : f).add(e);
+  u || O();
 }
-function v(t, e, s) {
-  C(e);
-  const i = { kind: s, listener: e };
-  return t.add(i), S(() => {
-    i.listener = void 0, t.delete(i);
+function d(s, e, t) {
+  k(e);
+  const i = { kind: t, listener: e };
+  return s.add(i), new g(() => {
+    i.listener = void 0, s.delete(i);
   });
 }
-function P(t) {
-  if (t.length === 1) throw t[0];
-  if (t.length > 1)
-    throw new AggregateError(t, "Reactive subscribers failed");
+function R(s) {
+  if (s.length === 1) throw s[0];
+  if (s.length > 1)
+    throw new AggregateError(s, "Reactive subscribers failed");
 }
-function T(t) {
-  a?.(t);
+function E(s) {
+  c?.(s);
 }
-function L(t) {
-  if (typeof t != "function") throw new TypeError("batch() expects a function");
-  f++;
+function I(s) {
+  if (typeof s != "function") throw new TypeError("batch() expects a function");
+  u++;
   let e;
   try {
-    const s = t();
-    h(s, "Reactive batches must be synchronous"), e = { ok: !0, value: s };
-  } catch (s) {
-    e = { ok: !1, error: s };
+    const t = s();
+    a(t, "Reactive batches must be synchronous"), e = { ok: !0, value: t };
+  } catch (t) {
+    e = { ok: !1, error: t };
   } finally {
-    f--;
+    u--;
   }
-  if (!f)
+  if (!u)
     try {
-      E();
-    } catch (s) {
-      e = e.ok ? { ok: !1, error: s } : { ok: !1, error: new AggregateError([e.error, s], "Reactive batch failed") };
+      O();
+    } catch (t) {
+      e = e.ok ? { ok: !1, error: t } : { ok: !1, error: new AggregateError([e.error, t], "Reactive batch failed") };
     }
   if (!e.ok) throw e.error;
   return e.value;
 }
-function q(t) {
-  let e = t, s = 0;
-  const i = /* @__PURE__ */ new Set(), n = {
-    get() {
-      return T(n), e;
-    },
-    set(r) {
-      if (a)
-        throw new TypeError("Computed signal calculations cannot write signals");
-      Object.is(e, r) || (e = r, s++, k(i));
-    },
-    subscribe(r) {
-      return v(i, r, "observer");
-    }
-  };
-  return d.set(n, {
-    get version() {
-      return s;
-    },
-    refresh() {
-    },
-    subscribeInvalidation: (r) => v(i, r, "dependency")
-  }), Object.freeze(n);
+function L(s) {
+  return new z(s).view;
 }
-function B(t) {
-  if (typeof t != "function") throw new TypeError("computed() expects a function");
-  return new j(t).view;
+function q(s) {
+  if (typeof s != "function") throw new TypeError("computed() expects a function");
+  return new P(s).view;
 }
-class j {
+class z {
+  #e = /* @__PURE__ */ new Set();
+  #t;
+  #s = 0;
+  view;
+  constructor(e) {
+    this.#t = e, this.view = Object.freeze({
+      get: () => (E(this.view), this.#t),
+      set: (t) => this.#r(t),
+      subscribe: (t) => d(this.#e, t, "observer")
+    }), l.set(this.view, this);
+  }
+  get version() {
+    return this.#s;
+  }
+  refresh() {
+  }
+  subscribeInvalidation(e) {
+    return d(this.#e, e, "dependency");
+  }
+  #r(e) {
+    if (c)
+      throw new TypeError("Computed signal calculations cannot write signals");
+    Object.is(this.#t, e) || (this.#t = e, this.#s++, S(this.#e));
+  }
+}
+class P {
   #e;
-  #s = /* @__PURE__ */ new Set();
-  #i = /* @__PURE__ */ new Map();
-  #n;
-  #r = !1;
-  #t = !0;
+  #t = /* @__PURE__ */ new Set();
+  #s = /* @__PURE__ */ new Map();
+  #r;
+  #n = !1;
+  #i = !0;
   #c = 0;
   view;
   constructor(e) {
     this.#e = e, this.view = Object.freeze({
       get: () => this.#o(),
-      subscribe: (s) => this.#h(s)
-    }), d.set(this.view, this);
+      subscribe: (t) => this.#h(t)
+    }), l.set(this.view, this);
   }
   get version() {
     return this.#c;
   }
   refresh() {
-    if (this.#r) throw new TypeError("Circular computed signal");
-    this.#r = !0;
+    if (this.#n) throw new TypeError("Circular computed signal");
+    this.#n = !0;
     try {
-      this.#l();
+      this.#v();
     } finally {
-      this.#r = !1;
+      this.#n = !1;
     }
   }
   #o() {
-    return this.refresh(), T(this.view), this.#a();
+    return this.refresh(), E(this.view), this.#a();
   }
   #a() {
-    const e = this.#n;
+    const e = this.#r;
     if (e.phase === "error") throw e.error;
     return e.value;
   }
   subscribeInvalidation(e) {
     return this.#h(e, "dependency");
   }
-  #h(e, s = "observer") {
-    C(e);
-    const i = { kind: s, listener: e }, n = this.#s.size === 0;
-    if (this.#s.add(i), n)
+  #h(e, t = "observer") {
+    k(e);
+    const i = { kind: t, listener: e }, r = this.#t.size === 0;
+    if (this.#t.add(i), r)
       try {
-        this.refresh(), s === "observer" && this.#a(), this.#f();
-      } catch (r) {
-        throw this.#s.delete(i), this.#s.size || this.#u(), r;
+        this.refresh(), t === "observer" && this.#a(), this.#f();
+      } catch (n) {
+        throw this.#t.delete(i), this.#t.size || this.#u(), n;
       }
-    return S(() => {
-      i.listener = void 0, this.#s.delete(i), this.#s.size || this.#u();
+    return new g(() => {
+      i.listener = void 0, this.#t.delete(i), this.#t.size || this.#u();
     });
   }
-  #p = () => {
-    this.#t || (this.#t = !0, k(this.#s));
+  #d = () => {
+    this.#i || (this.#i = !0, S(this.#t));
   };
   #u() {
-    for (const e of this.#i.values())
+    for (const e of this.#s.values())
       e.subscription?.dispose(), e.subscription = void 0;
   }
   #f() {
-    for (const e of this.#i.values())
-      e.subscription ??= e.node.subscribeInvalidation(this.#p);
-  }
-  #l() {
-    const e = this.#n;
-    if (e && !this.#t) {
-      for (const r of this.#i.values())
-        if (r.node.refresh(), r.version !== r.node.version) {
-          this.#t = !0;
-          break;
-        }
-      if (!this.#t) return;
-    }
-    const s = /* @__PURE__ */ new Set(), i = a;
-    a = (r) => s.add(r);
-    let n;
+    for (const e of this.#s.values())
+      e.subscription ??= e.node.subscribeInvalidation(this.#d);
+  }
+  #v() {
+    const e = this.#r;
+    if (e && !this.#i && !this.#p()) return;
+    this.#i = !0;
+    const t = /* @__PURE__ */ new Set(), i = this.#b(t);
+    this.#l(t), (!e || (i.phase === "value" ? e.phase !== "value" || !Object.is(e.value, i.value) : e.phase !== "error" || !Object.is(e.error, i.error))) && this.#c++, this.#r = i, this.#i = !1, this.#t.size && this.#f();
+  }
+  #p() {
+    for (const e of this.#s.values())
+      if (e.node.refresh(), e.version !== e.node.version) return !0;
+    return this.#i;
+  }
+  #b(e) {
+    const t = c;
+    c = (i) => e.add(i);
     try {
-      const r = this.#e();
-      h(r, "Computed signal calculations must be synchronous"), n = { phase: "value", value: r };
-    } catch (r) {
-      n = { phase: "error", error: r };
+      const i = this.#e();
+      return a(i, "Computed signal calculations must be synchronous"), { phase: "value", value: i };
+    } catch (i) {
+      return { phase: "error", error: i };
     } finally {
-      a = i;
+      c = t;
     }
-    for (const [r, o] of this.#i)
-      s.has(r) || (o.subscription?.dispose(), this.#i.delete(r));
-    for (const r of s) {
-      const o = d.get(r);
-      if (!o) continue;
-      const b = this.#i.get(r) ?? {
-        node: o,
-        version: o.version,
+  }
+  #l(e) {
+    for (const [t, i] of this.#s)
+      e.has(t) || (i.subscription?.dispose(), this.#s.delete(t));
+    for (const t of e) {
+      const i = l.get(t);
+      if (!i) continue;
+      const r = this.#s.get(t) ?? {
+        node: i,
+        version: i.version,
         subscription: void 0
       };
-      b.version = o.version, this.#i.set(r, b);
+      r.version = i.version, this.#s.set(t, r);
     }
-    (!e || (n.phase === "value" ? e.phase !== "value" || !Object.is(e.value, n.value) : e.phase !== "error" || !Object.is(e.error, n.error))) && this.#c++, this.#n = n, this.#t = !1, this.#s.size && this.#f();
   }
 }
-function C(t) {
-  if (typeof t != "function")
+function k(s) {
+  if (typeof s != "function")
     throw new TypeError("Signal subscriber must be a function");
 }
-class x {
+class j {
   #e;
+  #t;
   #s;
+  #r = { present: !1 };
+  #n = !1;
   #i;
-  #n = { present: !1 };
-  #r = !1;
-  #t;
   #c;
   #o;
   #a;
-  constructor(e, s, i) {
-    this.#e = { phase: "active", binding: { owner: e, source: s, observer: i } };
+  constructor(e, t, i) {
+    this.#e = { phase: "active", binding: { owner: e, source: t, observer: i } };
   }
   start() {
-    const { owner: e, source: s } = this.#b(), i = s.subscribe(() => this.#p());
-    if (A(i, "Readable.subscribe()"), this.#e.phase !== "active")
-      throw w(i), new Error("Observation is not active");
-    this.#s = i, this.#v();
-    const n = e.spawn((o) => this.#u(o)), r = I(n);
-    this.#t = n, r.then(
-      () => this.#y(n),
-      () => this.#y(n)
+    const { owner: e, source: t } = this.#y(), i = t.subscribe(() => this.#d());
+    if (x(i, "Readable.subscribe()"), this.#e.phase !== "active")
+      throw v(i), new Error("Observation is not active");
+    this.#t = i, this.#p();
+    const r = e.spawn((C) => this.#u(C)), n = A(r);
+    this.#i = r, n.then(
+      () => this.#m(r),
+      () => this.#m(r)
     );
   }
   attachOwnerCleanup(e) {
@@ -269,151 +274,133 @@ class x {
   dispose() {
     if (this.#a) return this.#a;
     const e = Promise.withResolvers();
-    return this.#a = e.promise, this.#c = void 0, this.#m("disposed"), this.#o?.(), this.#h().then(e.resolve, e.reject), e.promise;
+    return this.#a = e.promise, this.#c = void 0, this.#g("disposed"), this.#o?.(), this.#h().then(e.resolve, e.reject), e.promise;
   }
   async #h() {
     const e = [];
-    if (await this.#w(e), await u(this.#O(), e), await u(this.#d(), e), e.length === 1) throw e[0];
+    if (await this.#l(e), await h(this.#O(), e), await h(this.#w(), e), e.length === 1) throw e[0];
     if (e.length > 1) throw new AggregateError(e, "Observation cleanup failed");
   }
-  #p() {
-    this.#e.phase === "active" && (this.#r = !0, this.#o?.());
-  }
-  /**
-   * The serialization point. Sleeps until invalidated, then replaces the current
-   * lifetime, repeating while the value keeps changing. The inner loop collapses
-   * a burst of changes into one replacement per settled value rather than one per
-   * notification.
-   *
-   * A failure here stops the observation and reports it. There is no caller to
-   * return to — this runs in a spawned task — so continuing would mean silently
-   * observing a value with a lifetime that failed to establish.
-   */
+  #d() {
+    this.#e.phase === "active" && (this.#n = !0, this.#o?.());
+  }
+  // Stop on drain failure because continuing would observe a value whose resource ownership never established.
   async #u(e) {
     try {
       for (; this.#e.phase === "active" && !e.aborted; )
-        for (await this.#f(e); this.#e.phase === "active" && !e.aborted && this.#r; )
-          this.#r = !1, await this.#l(e);
-    } catch (s) {
-      if (this.#e.phase !== "active") throw s;
-      await this.#E(s);
+        for (await this.#f(e); this.#e.phase === "active" && !e.aborted && this.#n; )
+          this.#n = !1, await this.#v(e);
+    } catch (t) {
+      if (this.#e.phase !== "active") throw t;
+      await this.#E(t);
     }
   }
   #f(e) {
-    return this.#r || this.#e.phase !== "active" || e.aborted ? Promise.resolve() : new Promise((s) => {
+    return this.#n || this.#e.phase !== "active" || e.aborted ? Promise.resolve() : new Promise((t) => {
       const i = () => {
-        e.removeEventListener("abort", i), this.#o === i && (this.#o = void 0), s();
+        e.removeEventListener("abort", i), this.#o === i && (this.#o = void 0), t();
       };
-      this.#o = i, e.addEventListener("abort", i, { once: !0 }), (this.#r || this.#e.phase !== "active" || e.aborted) && i();
+      this.#o = i, e.addEventListener("abort", i, { once: !0 }), (this.#n || this.#e.phase !== "active" || e.aborted) && i();
     });
   }
-  /**
-   * Dispose the old lifetime, then create the new one, then call the observer.
-   * Strictly in that order: overlapping them would run two owners of whatever the
-   * observer set up, and a failed observer would leave the previous lifetime half
-   * disposed.
-   *
-   * `#observed` is cleared while no lifetime is current, so an interrupted
-   * replacement cannot leave a value marked as observed when nothing is
-   * observing it.
-   */
-  async #l(e) {
+  // Clear the observed marker during replacement so interruption cannot leave a value without its owner.
+  async #v(e) {
     if (this.#e.phase !== "active" || e.aborted) return;
-    const s = this.#e.binding.source.get();
-    if (this.#n.present && Object.is(s, this.#n.value)) return;
-    const i = this.#d();
-    i && await i.dispose(), this.#n = { present: !1 }, !(this.#e.phase !== "active" || e.aborted) && this.#v();
+    const t = this.#e.binding.source.get();
+    if (this.#r.present && Object.is(t, this.#r.value)) return;
+    const i = this.#w();
+    i && await i.dispose(), this.#r = { present: !1 }, !(this.#e.phase !== "active" || e.aborted) && this.#p();
   }
-  #v() {
-    const { owner: e, source: s } = this.#b(), i = e.lifetime("observation");
-    D(i, "ObservationOwner.lifetime()"), this.#i = i;
-    const n = s.get();
-    this.#g(n, i), this.#e.phase === "active" && (this.#n = { present: !0, value: n });
-  }
-  #g(e, s) {
-    const i = this.#b().observer(e, s);
-    h(i, "Observers must be synchronous; use owner.spawn() for async work");
-  }
-  async #w(e) {
-    const s = this.#s;
-    if (this.#s = void 0, !!s)
+  #p() {
+    const { owner: e, source: t } = this.#y(), i = e.lifetime("observation");
+    T(i, "ObservationOwner.lifetime()"), this.#s = i;
+    const r = t.get();
+    this.#b(r, i), this.#e.phase === "active" && (this.#r = { present: !0, value: r });
+  }
+  #b(e, t) {
+    const i = this.#y().observer(e, t);
+    a(i, "Observers must be synchronous; use owner.spawn() for async work");
+  }
+  async #l(e) {
+    const t = this.#t;
+    if (this.#t = void 0, !!t)
       try {
-        w(s);
+        v(t);
       } catch (i) {
         e.push(i);
       }
   }
-  #d() {
-    const e = this.#i;
-    return this.#i = void 0, e;
+  #w() {
+    const e = this.#s;
+    return this.#s = void 0, e;
   }
   #O() {
-    const e = this.#t;
-    return this.#t = void 0, e;
+    const e = this.#i;
+    return this.#i = void 0, e;
   }
   #S() {
     const e = this.#c;
     return this.#c = void 0, e;
   }
-  #y(e) {
-    this.#t === e && (this.#t = void 0);
+  #m(e) {
+    this.#i === e && (this.#i = void 0);
   }
   async #E(e) {
-    const s = [e];
-    throw this.#m("stopped"), this.#o?.(), await this.#w(s), await u(this.#d(), s), this.#t = void 0, await u(this.#S(), s), s.length === 1 ? s[0] : new AggregateError(s, "Observation stopped after a replacement failed");
+    const t = [e];
+    throw this.#g("stopped"), this.#o?.(), await this.#l(t), await h(this.#w(), t), this.#i = void 0, await h(this.#S(), t), t.length === 1 ? t[0] : new AggregateError(t, "Observation stopped after a replacement failed");
   }
-  #b() {
+  #y() {
     const e = this.#e;
     if (e.phase !== "active") throw new Error("Observation is not active");
     return e.binding;
   }
-  #m(e) {
-    this.#e = { phase: e }, this.#n = { present: !1 }, this.#r = !1;
+  #g(e) {
+    this.#e = { phase: e }, this.#r = { present: !1 }, this.#n = !1;
   }
 }
-function F(t, e, s) {
+function B(s, e, t) {
   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 (!t || typeof t.cleanup != "function" || typeof t.lifetime != "function" || typeof t.spawn != "function")
+  if (typeof t != "function") throw new TypeError("Observer must be a function");
+  if (!s || typeof s.cleanup != "function" || typeof s.lifetime != "function" || typeof s.spawn != "function")
     throw new TypeError("observe() expects an observation owner");
-  const i = new x(t, e, s), n = t.cleanup(() => i.dispose());
-  D(n, "ObservationOwner.cleanup()"), i.attachOwnerCleanup(n);
+  const i = new j(s, e, t), r = s.cleanup(() => i.dispose());
+  T(r, "ObservationOwner.cleanup()"), i.attachOwnerCleanup(r);
   try {
-    return i.start(), n;
-  } catch (r) {
+    return i.start(), r;
+  } catch (n) {
     throw i.dispose().catch(() => {
-    }), r;
+    }), n;
   }
 }
-function A(t, e) {
-  if (!t || typeof t.dispose != "function" || typeof t[m] != "function")
+function x(s, e) {
+  if (!s || typeof s.dispose != "function" || typeof s[w] != "function")
     throw new TypeError(`${e} must return a Disposable`);
 }
-function D(t, e) {
-  if (!t || typeof t.dispose != "function" || typeof t[g] != "function")
+function T(s, e) {
+  if (!s || typeof s.dispose != "function" || typeof s[y] != "function")
     throw new TypeError(`${e} must return an AsyncDisposable`);
 }
-function I(t) {
-  const e = t && typeof t.dispose == "function" && typeof t[g] == "function" ? O(t.result) : void 0;
+function A(s) {
+  const e = s && typeof s.dispose == "function" && typeof s[y] == "function" ? m(s.result) : void 0;
   if (!e)
     throw new TypeError("ObservationOwner.spawn() must return an ObservationTask");
   return e;
 }
-function w(t) {
-  h(t.dispose(), "Readable subscriptions must dispose synchronously");
+function v(s) {
+  a(s.dispose(), "Readable subscriptions must dispose synchronously");
 }
-async function u(t, e) {
-  if (t)
+async function h(s, e) {
+  if (s)
     try {
-      await t.dispose();
-    } catch (s) {
-      e.push(s);
+      await s.dispose();
+    } catch (t) {
+      e.push(t);
     }
 }
 export {
-  L as batch,
-  B as computed,
-  F as observe,
-  q as signal
+  I as batch,
+  q as computed,
+  B as observe,
+  L as signal
 };

package/dist/observe.d.ts

@@ -8,9 +8,5 @@ export interface ObservationOwner<Child extends AsyncDisposable = AsyncDisposabl
     readonly spawn: <T>(task: (signal: AbortSignal) => T | PromiseLike<T>) => ObservationTask<T>;
 }
 export type Observer<T, Child extends AsyncDisposable> = (value: T, lifetime: Child) => void;
-/**
- * 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 AsyncDisposable>(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,EAGL,KAAK,eAAe,EAEpB,KAAK,QAAQ,EACd,MAAM,YAAY,CAAC;AAwBpB,MAAM,WAAW,eAAe,CAAC,CAAC,GAAG,IAAI,CAAE,SAAQ,eAAe;IAChE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;CAC7B;AAED,MAAM,WAAW,gBAAgB,CAAC,KAAK,SAAS,eAAe,GAAG,eAAe;IAC/E,QAAQ,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,MAAM,OAAO,KAAK,eAAe,CAAC;IAC9D,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,KAAK,CAAC;IAC5C,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,KAAK,eAAe,CAAC,CAAC,CAAC,CAAC;CAC9F;AAED,MAAM,MAAM,QAAQ,CAAC,CAAC,EAAE,KAAK,SAAS,eAAe,IAAI,CAAC,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,KAAK,KAAK,IAAI,CAAC;AAqO7F;;;GAGG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,SAAS,eAAe,EACtD,KAAK,EAAE,gBAAgB,CAAC,KAAK,CAAC,EAC9B,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EACnB,QAAQ,EAAE,QAAQ,CAAC,CAAC,EAAE,KAAK,CAAC,GAC3B,eAAe,CA2BjB"}
+{"version":3,"file":"observe.d.ts","sourceRoot":"","sources":["../src/observe.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,eAAe,EAEpB,KAAK,QAAQ,EACd,MAAM,YAAY,CAAC;AAKpB,MAAM,WAAW,eAAe,CAAC,CAAC,GAAG,IAAI,CAAE,SAAQ,eAAe;IAChE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;CAC7B;AAED,MAAM,WAAW,gBAAgB,CAAC,KAAK,SAAS,eAAe,GAAG,eAAe;IAC/E,QAAQ,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,MAAM,OAAO,KAAK,eAAe,CAAC;IAC9D,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,KAAK,CAAC;IAC5C,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,KAAK,eAAe,CAAC,CAAC,CAAC,CAAC;CAC9F;AAED,MAAM,MAAM,QAAQ,CAAC,CAAC,EAAE,KAAK,SAAS,eAAe,IAAI,CAAC,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,KAAK,KAAK,IAAI,CAAC;AAgN7F,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,SAAS,eAAe,EACtD,KAAK,EAAE,gBAAgB,CAAC,KAAK,CAAC,EAC9B,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EACnB,QAAQ,EAAE,QAAQ,CAAC,CAAC,EAAE,KAAK,CAAC,GAC3B,eAAe,CAyBjB"}

package/dist/protocol.d.ts

@@ -7,7 +7,6 @@ export interface AsyncDisposable {
     dispose(): Promise<void>;
     [Symbol.asyncDispose](): Promise<void>;
 }
-/** 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":"AAEA,OAAO,EACL,oBAAoB,EACpB,qBAAqB,EACrB,kBAAkB,EAClB,aAAa,GACd,MAAM,oBAAoB,CAAC;AAE5B,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,2FAA2F;AAC3F,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,OAAO,EACL,oBAAoB,EACpB,qBAAqB,EACrB,kBAAkB,EAClB,aAAa,GACd,MAAM,oBAAoB,CAAC;AAE5B,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,WAAW,QAAQ,CAAC,CAAC;IACzB,GAAG,IAAI,CAAC,CAAC;IACT,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,UAAU,CAAC;CAC7C"}

package/dist/signals.d.ts

@@ -1,29 +1,12 @@
 import { 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> {
     readonly [dougongSignal]: true;
 }
 export interface Signal<T> extends ReadonlySignal<T> {
     readonly set: (value: T) => void;
 }
-/**
- * Defers notification until the outermost batch returns, so a group of writes is
- * observed once. Nested calls join the outer batch.
- *
- * Notifications are queued by subscription, not by callback, so the same
- * function subscribed to two signals is still called twice — deduplicating by
- * callback would silently merge two independent subscriptions.
- *
- * If both the body and the flush fail, both errors are reported. A subscriber
- * failing during flush must not hide why the batch itself failed.
- */
 export declare function batch<T>(callback: () => T): T;
-/**
- * A value with subscribers. Writes are compared with `Object.is`, so setting the
- * same value notifies nobody — which is what makes `computed` chains stable
- * under idempotent updates.
- */
 export declare function signal<T>(initialValue: T): Signal<T>;
 export declare function computed<T>(calculate: () => T): ReadonlySignal<T>;
 export {};

package/dist/signals.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"signals.d.ts","sourceRoot":"","sources":["../src/signals.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAkC,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAG3E,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,QAAQ,CAAC,GAAG,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;CAClC;AA4HD;;;;;;;;;;GAUG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC,CA4B7C;AAED;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAoCpD;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAGjE"}
+{"version":3,"file":"signals.d.ts","sourceRoot":"","sources":["../src/signals.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkC,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAG3E,OAAO,CAAC,MAAM,aAAa,EAAE,OAAO,MAAM,CAAC;AAE3C,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,QAAQ,CAAC,GAAG,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;CAClC;AA0GD,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,CAEpD;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAGjE"}

package/dist/sync-result.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sync-result.d.ts","sourceRoot":"","sources":["../src/sync-result.ts"],"names":[],"mappings":"AASA,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CASvE;AAKD,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,SAAS,CAO5E"}
+{"version":3,"file":"sync-result.d.ts","sourceRoot":"","sources":["../src/sync-result.ts"],"names":[],"mappings":"AACA,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAOvE;AAGD,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,SAAS,CAO5E"}

package/package.json

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