@dougongjs/reactive 0.4.0 → 0.5.0

package/dist/index.d.ts

@@ -1,15 +1,4 @@
-import { Readable } from './protocol';
+export { batch, computed, signal, type ReadonlySignal, type Signal } from './signals';
 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> {
-    readonly [dougongSignal]: true;
-}
-export interface Signal<T> extends ReadonlySignal<T> {
-    readonly set: (value: T) => void;
-}
-export { observe, type ObservationLifetime, type ObservationOwner, type ObservationTask, type Observer, } from './observe';
-export declare function batch<T>(callback: () => T): T;
-export declare function signal<T>(initialValue: T): Signal<T>;
-export declare function computed<T>(calculate: () => T): ReadonlySignal<T>;
+export { observe, type ObservationOwner, type ObservationTask, type Observer } from './observe';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkC,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAG3E,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,QAAQ,CAAC,GAAG,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;CAClC;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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,cAAc,EAAE,KAAK,MAAM,EAAE,MAAM,WAAW,CAAC;AACtF,YAAY,EAAE,eAAe,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACxE,OAAO,EAAE,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,eAAe,EAAE,KAAK,QAAQ,EAAE,MAAM,WAAW,CAAC"}

package/dist/index.js

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

package/dist/observe.d.ts

@@ -2,20 +2,15 @@ import { AsyncDisposable, Readable } from './protocol';
 export interface ObservationTask<T = void> extends AsyncDisposable {
     readonly result: Promise<T>;
 }
-export interface ObservationLifetime extends AsyncDisposable {
-    readonly cleanup: (dispose: () => unknown) => AsyncDisposable;
-    readonly lifetime: (label: string) => ObservationLifetime;
-    readonly spawn: <T>(task: (signal: AbortSignal) => T | PromiseLike<T>) => ObservationTask<T>;
-}
-export interface ObservationOwner<Child extends ObservationLifetime = ObservationLifetime> {
+export interface ObservationOwner<Child extends AsyncDisposable = AsyncDisposable> {
     readonly cleanup: (dispose: () => unknown) => AsyncDisposable;
     readonly lifetime: (label: string) => Child;
     readonly spawn: <T>(task: (signal: AbortSignal) => T | PromiseLike<T>) => ObservationTask<T>;
 }
-export type Observer<T, Child extends ObservationLifetime> = (value: T, lifetime: Child) => void;
+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 ObservationLifetime>(owner: ObservationOwner<Child>, source: Readable<T>, observer: Observer<T, Child>): AsyncDisposable;
+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,EAEd,MAAM,YAAY,CAAC;AAGpB,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,QAAQ,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,MAAM,OAAO,KAAK,eAAe,CAAC;IAC9D,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,mBAAmB,CAAC;IAC1D,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,WAAW,gBAAgB,CAAC,KAAK,SAAS,mBAAmB,GAAG,mBAAmB;IACvF,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,mBAAmB,IAAI,CAAC,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,KAAK,KAAK,IAAI,CAAC;AA+NjG;;;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,CA2BjB"}
+{"version":3,"file":"observe.d.ts","sourceRoot":"","sources":["../src/observe.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,eAAe,EAEpB,KAAK,QAAQ,EAEd,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;AA2N7F;;;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"}

package/dist/protocol.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../src/protocol.ts"],"names":[],"mappings":"AAAA,2FAA2F;AAC3F,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,eAAO,MAAM,aAAa,EAAE,OAAO,MAAM,CAAC,OAGhB,CAAC;AAC3B,eAAO,MAAM,kBAAkB,EAAE,OAAO,MAAM,CAAC,YAGhB,CAAC;AAEhC,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"}
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../src/protocol.ts"],"names":[],"mappings":"AAMA,2FAA2F;AAC3F,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,eAAO,MAAM,aAAa,EAAE,OAAO,MAAM,CAAC,OAGhB,CAAC;AAC3B,eAAO,MAAM,kBAAkB,EAAE,OAAO,MAAM,CAAC,YAGhB,CAAC;AAEhC,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/dist/signals.d.ts

@@ -0,0 +1,30 @@
+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 {};
+//# sourceMappingURL=signals.d.ts.map

package/dist/signals.d.ts.map

@@ -0,0 +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"}

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

@@ -1 +1 @@
-{"version":3,"file":"sync-result.d.ts","sourceRoot":"","sources":["../src/sync-result.ts"],"names":[],"mappings":"AAAA,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAQvE;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,WAAW,CAAC,OAAO,CAAC,CAGxE"}
+{"version":3,"file":"sync-result.d.ts","sourceRoot":"","sources":["../src/sync-result.ts"],"names":[],"mappings":"AAaA,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAQvE;AAID,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,WAAW,CAAC,OAAO,CAAC,CAGxE"}

package/package.json

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