@dougongjs/reactive 0.9.0 → 0.11.0

package/README.md

@@ -2,10 +2,10 @@
 
 Independent synchronous signals and structurally owned reactive generations. No external runtime dependencies.
 
-Upgrading from 0.8.3? Read the [migration guide](https://tangerg.github.io/dougong/en/guide/migrating-to-0.9) and [0.9.0 release notes](https://tangerg.github.io/dougong/en/reference/release-0.9.0).
+Upgrading from 0.9? Read the [migration guide](https://tangerg.github.io/dougong/en/guide/migrating-to-0.10) and [0.10.0 release notes](https://tangerg.github.io/dougong/en/reference/release-0.10.0). From 0.8.3, complete [Migrating to 0.9.0](https://tangerg.github.io/dougong/en/guide/migrating-to-0.9) first.
 
 ```ts
-import { batch, computed, signal } from "@dougongjs/reactive";
+import { batch, computed, disposeSymbol, signal } from "@dougongjs/reactive";
 
 const first = signal("Dougong");
 const last = signal("Plugins");
@@ -15,13 +15,19 @@ batch(() => {
   first.set("Typed");
   last.set("Composition");
 });
-subscription[Symbol.dispose]();
+subscription[disposeSymbol]();
 ```
 
 `Readable<T>` exposes `get()` and `subscribe()`. The subscription implements standard `Symbol.dispose`; callbacks notify changes without replay. `bridge(owner, readable)` adapts another module copy or implementation into the local dependency graph. Its subscription and terminal detachment belong to the supplied owner through `defer`.
 
+`batch`, `computed`, `subscribe` and `observe` require synchronous callbacks in both their types and runtime checks. Direct Promise results, PromiseLike results and mixed asynchronous branches are rejected, including when a caller explicitly supplies `void`. Ordinary synchronous return values remain inferred; `Observer<T, Child, Result>` can describe an explicit non-void result. Values whose type was already erased still receive the runtime check.
+
 `observe(owner, readable, observer)` disposes the previous child before building the next one. The structural owner supplies `child`, `defer` and `spawn`; only the returned child needs `Symbol.asyncDispose`; no framework base class is required. Use `generation.spawn` for asynchronous observer work.
 
-ESM; Node.js 22+, Chrome/Edge 119+, Firefox 124+, Safari 17.4+.
+`ObservationTask` describes completion only: it is not generic, and its `result` is `PromiseLike<unknown>`. The required `spawn` accepts a task returning `void | PromiseLike<void>`. Owners may provide a richer generic task API without coupling observation to their result payloads.
+
+Results inheriting this module's realm's `Promise.prototype` select the intrinsic native protocol, including decorated local Promises and subclasses. Other results use one captured structural `then`; display tags do not select a protocol. Foreign Promises must expose a conforming public `then`. Adapt decorated foreign results in their origin realm, and box payloads there when another assimilation would change them. See the guide for the precise boundary and disposal guarantees.
+
+ESM; <!-- runtime-baseline:start -->Node.js `^24.22.0 || >=26.10.0`, Chrome ≥ 119, Edge ≥ 119, Firefox ≥ 124, Safari ≥ 17.4<!-- runtime-baseline:end -->.
 
 [Guide](https://tangerg.github.io/dougong/en/guide/reactive)

package/dist/abort.d.ts

@@ -1,4 +1,5 @@
+import { SynchronousResult } from './async-result.js';
 export declare function isAborted(signal: AbortSignal): boolean;
 export declare function abortReason(signal: AbortSignal): unknown;
-export declare function onAbort(signal: AbortSignal, callback: (reason: unknown) => void): () => void;
+export declare function onAbort<Result>(signal: AbortSignal, callback: (reason: unknown) => SynchronousResult<Result>): () => void;
 //# sourceMappingURL=abort.d.ts.map

package/dist/abort.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"abort.d.ts","sourceRoot":"","sources":["../src/abort.ts"],"names":[],"mappings":"AAIA,wBAAgB,SAAS,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAEtD;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAExD;AAED,wBAAgB,OAAO,CAAC,MAAM,EAAE,WAAW,EAAE,QAAQ,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,GAAG,MAAM,IAAI,CA6B5F"}
+{"version":3,"file":"abort.d.ts","sourceRoot":"","sources":["../src/abort.ts"],"names":[],"mappings":"AAEA,OAAO,EAAqB,KAAK,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAG9E,wBAAgB,SAAS,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAEtD;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAExD;AAED,wBAAgB,OAAO,CAAC,MAAM,EAC5B,MAAM,EAAE,WAAW,EACnB,QAAQ,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,iBAAiB,CAAC,MAAM,CAAC,GACvD,MAAM,IAAI,CA6BZ"}

package/dist/async-result.d.ts

@@ -0,0 +1,10 @@
+type WithoutCallableThen<T> = T extends object ? "then" extends keyof T ? Extract<T["then"], (...arguments_: never[]) => unknown> extends never ? T : never : T : T;
+export type SynchronousResult<T> = (T & NoInfer<WithoutCallableThen<T>>) | (T & undefined);
+export interface ResolvedValue<T> {
+    readonly value: T;
+}
+export declare function resolveValue<T>(value: T | PromiseLike<T>): Promise<ResolvedValue<Awaited<T>>>;
+export declare function assertSynchronous(value: unknown, message: string): void;
+export declare function captureThenable(value: unknown): Promise<ResolvedValue<unknown>> | undefined;
+export {};
+//# sourceMappingURL=async-result.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"async-result.d.ts","sourceRoot":"","sources":["../src/async-result.ts"],"names":[],"mappings":"AAIA,KAAK,mBAAmB,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,GAC1C,MAAM,SAAS,MAAM,CAAC,GACpB,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,GAAG,UAAU,EAAE,KAAK,EAAE,KAAK,OAAO,CAAC,SAAS,KAAK,GACnE,CAAC,GACD,KAAK,GACP,CAAC,GACH,CAAC,CAAC;AAIN,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;AAE3F,MAAM,WAAW,aAAa,CAAC,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;CACnB;AAED,wBAAsB,YAAY,CAAC,CAAC,EAClC,KAAK,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,GACxB,OAAO,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAGpC;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAUvE;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,GAAG,SAAS,CA0B3F"}

package/dist/bridge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bridge.d.ts","sourceRoot":"","sources":["../src/bridge.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,eAAe,EAEpB,KAAK,QAAQ,EACd,MAAM,eAAe,CAAC;AACvB,OAAO,EAAU,KAAK,cAAc,EAAe,MAAM,cAAc,CAAC;AAExE,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,OAAO,KAAK,eAAe,CAAC;CAC7D;AA2ID,wBAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAmBpF"}
+{"version":3,"file":"bridge.d.ts","sourceRoot":"","sources":["../src/bridge.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,eAAe,EAEpB,KAAK,QAAQ,EACd,MAAM,eAAe,CAAC;AACvB,OAAO,EAAiB,KAAK,cAAc,EAAe,MAAM,cAAc,CAAC;AAG/E,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,OAAO,KAAK,eAAe,CAAC;CAC7D;AAyJD,wBAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAmBpF"}

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { batch, computed, signal, type ReadonlySignal, type Signal } from './signals.js';
 export { bridge, type BridgeOwner } from './bridge.js';
-export type { AsyncDisposable, Disposable, Readable } from './protocol.js';
+export { asyncDisposeSymbol, disposeSymbol, type AsyncDisposable, type Disposable, type Readable, } from './protocol.js';
 export { observe, type ObservationOwner, type ObservationTask, type Observer } from './observe.js';
 //# 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,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,cAAc,EAAE,KAAK,MAAM,EAAE,MAAM,cAAc,CAAC;AACzF,OAAO,EAAE,MAAM,EAAE,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AACvD,YAAY,EAAE,eAAe,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC3E,OAAO,EAAE,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,eAAe,EAAE,KAAK,QAAQ,EAAE,MAAM,cAAc,CAAC"}
+{"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,cAAc,CAAC;AACzF,OAAO,EAAE,MAAM,EAAE,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,EACL,kBAAkB,EAClB,aAAa,EACb,KAAK,eAAe,EACpB,KAAK,UAAU,EACf,KAAK,QAAQ,GACd,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,eAAe,EAAE,KAAK,QAAQ,EAAE,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -7,14 +7,20 @@ function n(e, t) {
 	return e ?? Symbol.for(t);
 }
 t(Promise.withResolvers);
-var r = n(Symbol.dispose, "Symbol.dispose"), i = n(Symbol.asyncDispose, "Symbol.asyncDispose");
-// src/synchronous-result.ts
-function a(e, t) {
-	let n = o(e);
+var r = n(Symbol.dispose, "Symbol.dispose"), i = n(Symbol.asyncDispose, "Symbol.asyncDispose"), a = Promise.prototype, o = a.then;
+async function s(e) {
+	return l(e) ?? Object.freeze({ value: e });
+}
+function c(e, t) {
+	let n = l(e);
 	if (n) throw n.then(() => void 0, () => void 0), TypeError(t);
 }
-function o(e) {
+function l(e) {
 	if (e === null || typeof e != "object" && typeof e != "function") return;
+	if (u(e)) {
+		let t = Promise.withResolvers();
+		return Reflect.apply(o, e, [(e) => t.resolve(Object.freeze({ value: e })), t.reject]), t.promise;
+	}
 	let t = e.then;
 	if (typeof t != "function") return;
 	let n = Promise.withResolvers();
@@ -24,10 +30,19 @@ function o(e) {
 		} catch (e) {
 			n.reject(e);
 		}
-	}), n.promise;
+	}), n.promise.then((e) => Object.freeze({ value: e }));
+}
+function u(e) {
+	let t = /* @__PURE__ */ new Set();
+	for (let n = Object.getPrototypeOf(e); n !== null; n = Object.getPrototypeOf(n)) {
+		if (n === a) return !0;
+		if (t.has(n)) throw TypeError("Result has a cyclic prototype chain");
+		t.add(n);
+	}
+	return !1;
 }
 // src/protocol.ts
-function s(e, t) {
+function d(e, t) {
 	let n = e?.get, r = e?.subscribe;
 	if (typeof n != "function" || typeof r != "function") throw TypeError(`${t} expects a readable source`);
 	return Object.freeze({
@@ -35,22 +50,22 @@ function s(e, t) {
 		subscribe: (t) => Reflect.apply(r, e, [t])
 	});
 }
-function c(e) {
+function f(e) {
 	let t = e?.[r];
-	return typeof t != "function" && u(e, "Readable.subscribe() must return a Disposable"), () => a(Reflect.apply(t, e, []), "Readable subscriptions must dispose synchronously");
+	return typeof t != "function" && m(e, "Readable.subscribe() must return a Disposable"), () => c(Reflect.apply(t, e, []), "Readable subscriptions must dispose synchronously");
 }
-function l(e, t) {
+function p(e, t) {
 	let n = e?.[i];
-	return typeof n != "function" && u(e, t), () => Reflect.apply(n, e, []);
+	return typeof n != "function" && m(e, t), () => Reflect.apply(n, e, []);
 }
-function u(e, t) {
-	throw a(e, t), TypeError(t);
+function m(e, t) {
+	throw c(e, t), TypeError(t);
 }
-function d(e) {
+function h(e) {
 	if (typeof e != "function") throw TypeError("Signal subscriber must be a function");
 }
 // src/signals.ts
-var f = 0, p = 0, m = !1, h = !1, g = /* @__PURE__ */ new Set(), _ = /* @__PURE__ */ new Set(), v, y = [], b = class {
+var g = 0, _ = 0, v = !1, y = !1, b = /* @__PURE__ */ new Set(), x = /* @__PURE__ */ new Set(), S, C = [], w = class {
 	#e;
 	constructor(e) {
 		this.#e = e, Object.freeze(this);
@@ -60,64 +75,64 @@ var f = 0, p = 0, m = !1, h = !1, g = /* @__PURE__ */ new Set(), _ = /* @__PURE_
 		this.#e = void 0, e?.();
 	}
 };
-function x() {
-	if (m) return;
+function T() {
+	if (v) return;
 	let e = [];
-	m = !0;
+	v = !0;
 	try {
-		for (; g.size;) {
-			let t = g.values().next().value;
-			g.delete(t);
+		for (; b.size;) {
+			let t = b.values().next().value;
+			b.delete(t);
 			let n = t.listener;
 			if (n) try {
-				a(n(), "Signal subscribers must be synchronous");
+				c(n(), "Signal subscribers must be synchronous");
 			} catch (t) {
 				e.push(t);
 			}
 		}
 	} finally {
-		g.clear(), m = !1;
+		b.clear(), v = !1;
 	}
-	w(e);
+	O(e);
 }
-function S(e) {
-	for (let t of e) (t.kind === "dependency" ? _ : g).add(t);
-	if (!h) {
-		h = !0;
+function E(e) {
+	for (let t of e) (t.kind === "dependency" ? x : b).add(t);
+	if (!y) {
+		y = !0;
 		try {
-			for (; _.size;) {
-				let e = _.values().next().value;
-				_.delete(e);
+			for (; x.size;) {
+				let e = x.values().next().value;
+				x.delete(e);
 				let t = e.listener;
 				t?.();
 			}
 		} finally {
-			h = !1, _.clear();
+			y = !1, x.clear();
 		}
-		p || x();
+		_ || T();
 	}
 }
-function C(e, t, n) {
-	d(t);
+function D(e, t, n) {
+	h(t);
 	let r = {
 		kind: n,
 		listener: t
 	};
-	return e.add(r), new b(() => {
+	return e.add(r), new w(() => {
 		r.listener = void 0, e.delete(r);
 	});
 }
-function w(e) {
+function O(e) {
 	if (e.length === 1) throw e[0];
 	if (e.length > 1) throw AggregateError(e, "Reactive subscribers failed");
 }
-function T(e) {
+function k(e) {
 	if (typeof e != "function") throw TypeError("batch() expects a function");
-	p++;
+	_++;
 	let t;
 	try {
 		let n = e();
-		a(n, "Reactive batches must be synchronous"), t = {
+		c(n, "Reactive batches must be synchronous"), t = {
 			succeeded: !0,
 			value: n
 		};
@@ -127,10 +142,10 @@ function T(e) {
 			error: e
 		};
 	} finally {
-		p--;
+		_--;
 	}
-	if (!p) try {
-		x();
+	if (!_) try {
+		T();
 	} catch (e) {
 		t = t.succeeded ? {
 			succeeded: !1,
@@ -143,23 +158,23 @@ function T(e) {
 	if (!t.succeeded) throw t.error;
 	return t.value;
 }
-function E(e) {
-	return new O(e).view;
+function A(e) {
+	return new M(e).view;
 }
-function D(e) {
+function j(e) {
 	if (typeof e != "function") throw TypeError("computed() expects a function");
-	return new k(e).view;
+	return new N(e).view;
 }
-var O = class {
+var M = class {
 	#e = /* @__PURE__ */ new Set();
 	#t;
 	#n = 0;
 	view;
 	constructor(e) {
 		this.#t = e, this.view = Object.freeze({
-			get: () => (v?.add(this), this.#t),
+			get: () => (S?.add(this), this.#t),
 			set: (e) => this.#r(e),
-			subscribe: (e) => C(this.#e, e, "observer")
+			subscribe: (e) => D(this.#e, e, "observer")
 		});
 	}
 	get version() {
@@ -167,13 +182,13 @@ var O = class {
 	}
 	refresh() {}
 	subscribeInvalidation(e) {
-		return C(this.#e, e, "dependency");
+		return D(this.#e, e, "dependency");
 	}
 	#r(e) {
-		if (v) throw TypeError("Computed signal calculations cannot write signals");
-		Object.is(this.#t, e) || (this.#t = e, f++, this.#n++, S(this.#e));
+		if (S) throw TypeError("Computed signal calculations cannot write signals");
+		Object.is(this.#t, e) || (this.#t = e, g++, this.#n++, E(this.#e));
 	}
-}, k = class e {
+}, N = class e {
 	#e;
 	#t = /* @__PURE__ */ new Set();
 	#n = /* @__PURE__ */ new Map();
@@ -181,7 +196,7 @@ var O = class {
 	#i = -1;
 	#a;
 	#o;
-	#s = !0;
+	#s = -1;
 	#c = 0;
 	view;
 	constructor(e) {
@@ -194,33 +209,33 @@ var O = class {
 		return this.#c;
 	}
 	refresh() {
-		if (this.#a !== void 0) throw v && this.#l(this.#a, v), TypeError("Circular computed signal");
-		this.#a = y.length, y.push(this);
+		if (this.#a !== void 0) throw S && this.#l(this.#a, S), TypeError("Circular computed signal");
+		this.#a = C.length, C.push(this);
 		try {
 			this.#g();
 		} finally {
-			y.pop(), this.#a = void 0;
+			C.pop(), this.#a = void 0;
 		}
 	}
 	#l(t, n) {
 		let r = /* @__PURE__ */ new Set();
-		for (let e of y.slice(t)) for (let t of e.#o ?? e.#n.keys()) r.add(t);
+		for (let e of C.slice(t)) for (let t of e.#o ?? e.#n.keys()) r.add(t);
 		for (let t of r) if (t instanceof e) for (let e of t.#n.keys()) r.add(e);
 		else n.add(t);
 	}
 	#u() {
-		return this.refresh(), v?.add(this), this.#d();
+		return this.refresh(), S?.add(this), this.#d();
 	}
 	#d() {
 		let e = this.#r;
-		if (e.phase === "error") throw e.error;
+		if (e.outcome === "error") throw e.error;
 		return e.value;
 	}
 	subscribeInvalidation(e) {
 		return this.#f(e, "dependency");
 	}
 	#f(e, t = "observer") {
-		d(e);
+		h(e);
 		let n = {
 			kind: t,
 			listener: e
@@ -230,12 +245,12 @@ var O = class {
 		} catch (e) {
 			throw this.#t.delete(n), this.#t.size || this.#m(), e;
 		}
-		return new b(() => {
+		return new w(() => {
 			n.listener = void 0, this.#t.delete(n), this.#t.size || this.#m();
 		});
 	}
 	#p = () => {
-		this.#s || (this.#s = !0, S(this.#t));
+		this.#s !== g && (this.#s = g, E(this.#t));
 	};
 	#m() {
 		for (let e of this.#n.values()) e.subscription?.[r](), e.subscription = void 0;
@@ -245,34 +260,33 @@ var O = class {
 	}
 	#g() {
 		let e = this.#r;
-		if (e && !this.#s && (this.#i === f || !this.#_())) {
-			this.#i = f;
+		if (e && this.#s <= this.#i && (this.#i === g || !this.#_())) {
+			this.#i = g;
 			return;
 		}
-		this.#s = !0;
 		let t = /* @__PURE__ */ new Set(), n = this.#v(t);
-		this.#y(t), (!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.#r = n, this.#i = f, this.#s = !1, this.#t.size && this.#h();
+		this.#y(t), (!e || (n.outcome === "value" ? e.outcome !== "value" || !Object.is(e.value, n.value) : e.outcome !== "error" || !Object.is(e.error, n.error))) && this.#c++, this.#r = n, this.#i = g, this.#t.size && this.#h();
 	}
 	#_() {
 		for (let [t, n] of this.#n) if (t instanceof e && t.#a !== void 0 || (t.refresh(), n.version !== t.version)) return !0;
-		return this.#s;
+		return this.#s > this.#i;
 	}
 	#v(e) {
-		let t = v;
-		this.#o = e, v = e;
+		let t = S;
+		this.#o = e, S = e;
 		try {
 			let e = this.#e, t = e();
-			return a(t, "Computed signal calculations must be synchronous"), {
-				phase: "value",
+			return c(t, "Computed signal calculations must be synchronous"), {
+				outcome: "value",
 				value: t
 			};
 		} catch (e) {
 			return {
-				phase: "error",
+				outcome: "error",
 				error: e
 			};
 		} finally {
-			v = t, this.#o = void 0;
+			S = t, this.#o = void 0;
 		}
 	}
 	#y(e) {
@@ -285,22 +299,22 @@ var O = class {
 			});
 		}
 	}
-}, A = class {
+}, P = "Readable bridge has been disposed", F = class {
 	#e;
 	#t;
 	#n;
 	#r;
 	view;
 	constructor(e) {
-		this.#e = E({
-			phase: "value",
+		this.#e = A({
+			outcome: "value",
 			source: e,
 			value: e.get()
 		}), this.view = Object.freeze({
 			get: () => {
 				let e = this.#e?.get();
-				if (!e) throw Error("Readable bridge has been disposed");
-				if (e.phase === "error") throw e.error;
+				if (!e) throw Error(P);
+				if (e.outcome === "error") throw e.error;
 				return e.value;
 			},
 			subscribe: (e) => this.#o(e)
@@ -309,21 +323,22 @@ var O = class {
 	start(e) {
 		let t = !0, n;
 		try {
-			n = l(e.defer(() => (this[r](), t ? Promise.resolve().then(() => this.#i()) : void 0)), "BridgeOwner.defer() must return an AsyncDisposable");
+			n = p(e.defer(() => (this[r](), t ? Promise.resolve().then(() => this.#i()) : void 0)), "BridgeOwner.defer() must return an AsyncDisposable");
 			let i = this.#e?.get();
-			if (!i) throw Error("Readable bridge has been disposed");
-			let a = c(i.source.subscribe(() => this.#a()));
+			if (!i) throw Error(P);
+			let a = f(i.source.subscribe(() => this.#a()));
 			if (this.#t = a, !this.#e?.get()) {
 				try {
 					a(), this.#t = void 0;
 				} catch (e) {
 					this.#r = { value: e };
 				}
-				throw Error("Readable bridge has been disposed");
+				throw Error(P);
 			}
 			this.#a(), this.view.get();
 		} catch (e) {
-			throw n && Promise.resolve().then(n).catch(() => void 0), e;
+			let t = n;
+			throw t && Promise.resolve().then(() => s(t())).catch(() => void 0), e;
 		} finally {
 			t = !1;
 		}
@@ -332,35 +347,37 @@ var O = class {
 		if (this.#r) throw this.#r.value;
 	}
 	#a() {
-		let e = this.#e?.get();
-		if (!e) return;
-		let t = Symbol();
-		this.#n = t;
-		try {
-			let { source: n } = e, r;
+		k(() => {
+			let e = this.#e?.get();
+			if (!e) return;
+			let t = Symbol();
+			this.#n = t;
 			try {
-				r = {
-					phase: "value",
-					source: n,
-					value: n.get()
-				};
-			} catch (e) {
-				r = {
-					phase: "error",
-					source: n,
-					error: e
-				};
+				let { source: n } = e, r;
+				try {
+					r = {
+						outcome: "value",
+						source: n,
+						value: n.get()
+					};
+				} catch (e) {
+					r = {
+						outcome: "error",
+						source: n,
+						error: e
+					};
+				}
+				if (this.#n !== t || this.#e?.get() !== e || e.outcome === "value" && r.outcome === "value" && Object.is(e.value, r.value) || e.outcome === "error" && r.outcome === "error" && Object.is(e.error, r.error)) return;
+				this.#e?.set(r);
+			} finally {
+				this.#n = void 0;
 			}
-			if (this.#n !== t || this.#e?.get() !== e || e.phase === "value" && r.phase === "value" && Object.is(e.value, r.value) || e.phase === "error" && r.phase === "error" && Object.is(e.error, r.error)) return;
-			this.#e?.set(r);
-		} finally {
-			this.#n = void 0;
-		}
+		});
 	}
 	#o(e) {
 		let t = this.#e;
-		if (!t?.get()) throw Error("Readable bridge has been disposed");
-		d(e);
+		if (!t?.get()) throw Error(P);
+		h(e);
 		let n = t.subscribe(() => (this.#e?.get() || n[r](), e()));
 		return n;
 	}
@@ -386,10 +403,10 @@ var O = class {
 		}
 	}
 };
-function j(e, t) {
+function I(e, t) {
 	let n = e?.defer;
 	if (typeof n != "function") throw TypeError("bridge() expects a resource owner");
-	let i = s(t, "bridge()"), a = { defer: (t) => Reflect.apply(n, e, [t]) }, o = new A(i);
+	let i = d(t, "bridge()"), a = { defer: (t) => Reflect.apply(n, e, [t]) }, o = new F(i);
 	try {
 		return o.start(a), o.view;
 	} catch (e) {
@@ -402,15 +419,15 @@ function j(e, t) {
 	}
 }
 // src/abort.ts
-function M(e) {
+function L(e) {
 	return Reflect.get(AbortSignal.prototype, "aborted", e);
 }
-function N(e) {
+function R(e) {
 	return Reflect.get(AbortSignal.prototype, "reason", e);
 }
-function P(t, n) {
+function z(t, n) {
 	if (typeof n != "function") throw TypeError("Abort listener must be a function");
-	if (M(t)) return n(N(t)), () => {};
+	if (L(t)) return B(n, R(t)), () => {};
 	let r = {
 		signal: t,
 		callback: n
@@ -419,14 +436,17 @@ function P(t, n) {
 		r = void 0, i?.(), i = void 0;
 	}
 	function o() {
-		if (!r || !M(r.signal)) return;
-		let { signal: e, callback: t } = r, n = N(e);
-		a(), t(n);
+		if (!r || !L(r.signal)) return;
+		let { signal: e, callback: t } = r, n = R(e);
+		a(), B(t, n);
 	}
 	return i = e(t, o), r ? o() : a(), a;
 }
+function B(e, t) {
+	c(e(t), "Abort listeners must be synchronous");
+}
 // src/observe.ts
-var F = class {
+var V = "observation", H = class {
 	#e;
 	#t;
 	#n;
@@ -438,6 +458,7 @@ var F = class {
 	#c;
 	#l;
 	#u;
+	#d;
 	constructor(e, t, n) {
 		this.#e = {
 			phase: "active",
@@ -451,61 +472,75 @@ var F = class {
 	start() {
 		this.#i = !0;
 		try {
-			this.#d();
+			this.#f();
 		} finally {
 			this.#i = !1;
 		}
 	}
-	#d() {
-		let { owner: e, source: t } = this.#S();
-		this.#t = c(t.subscribe(() => this.#p())), this.#g();
-		let n = e.spawn((e) => this.#m(e)), r = l(n, "ObservationOwner.spawn() must return an ObservationTask");
+	#f() {
+		let { source: e } = this.#w();
+		this.#t = f(e.subscribe(() => this.#h())), this.#v();
+		let { owner: t } = this.#w(), n = t.spawn((e) => this.#g(e)), r = p(n, "ObservationOwner.spawn() must return an ObservationTask");
 		this.#s = r;
-		let i = o(n.result);
+		let i = l(n.result);
 		if (!i) throw TypeError("ObservationOwner.spawn() must return an ObservationTask");
-		i.then(() => this.#b(r), () => this.#b(r));
+		i.then(() => this.#S(r), () => this.#S(r));
 	}
 	attachOwnerCleanup(e) {
-		this.#c = e;
+		this.#d || (this.#c = e);
+	}
+	handle = Object.freeze({ [i]: () => this.#p() });
+	#p() {
+		if (this.#l) return this.#l;
+		let e = this.#c;
+		if (!e) return this.dispose();
+		let t = Promise.withResolvers();
+		this.#l = t.promise;
+		try {
+			s(e()).then(() => t.resolve(), t.reject);
+		} catch (e) {
+			t.reject(e);
+		}
+		return t.promise;
 	}
 	dispose() {
-		if (this.#u) return this.#u;
+		if (this.#d) return this.#d;
 		let e = Promise.withResolvers();
-		return this.#u = e.promise, this.#c = void 0, this.#C("disposed"), this.#l?.(), (this.#i ? Promise.resolve().then(() => this.#f()) : this.#f()).then(e.resolve, e.reject), e.promise;
+		return this.#d = e.promise, this.#c = void 0, this.#T("disposed"), this.#u?.(), (this.#i ? Promise.resolve().then(() => this.#m()) : this.#m()).then(e.resolve, e.reject), e.promise;
 	}
-	async #f() {
+	async #m() {
 		let e = [];
 		try {
 			this.#t?.(), this.#t = void 0;
 		} catch (t) {
 			e.push(t);
 		}
-		await L(this.#y(), e);
+		await W(this.#x(), e);
 		try {
-			await this.#v();
+			await this.#b();
 		} catch (t) {
 			e.push(t);
 		}
 		if (e.length === 1) throw e[0];
 		if (e.length > 1) throw AggregateError(e, "Observation cleanup failed");
 	}
-	#p() {
-		this.#e.phase === "active" && (this.#o = !0, this.#l?.());
+	#h() {
+		this.#e.phase === "active" && (this.#o = !0, this.#u?.());
 	}
-	async #m(e) {
-		let t = P(e, () => this.#l?.());
+	async #g(e) {
+		let t = z(e, () => this.#u?.());
 		try {
-			for (; this.#e.phase === "active" && !M(e);) {
+			for (; this.#e.phase === "active" && !L(e);) {
 				if (!this.#o) {
 					let e = Promise.withResolvers();
-					this.#l = e.resolve, await e.promise, this.#l = void 0;
+					this.#u = e.resolve, await e.promise, this.#u = void 0;
 				}
-				for (; this.#e.phase === "active" && !M(e) && this.#o;) this.#o = !1, await this.#h(e);
+				for (; this.#e.phase === "active" && !L(e) && this.#o;) this.#o = !1, await this.#_(e);
 			}
 		} catch (e) {
 			if (this.#e.phase !== "active") throw e;
 			try {
-				await this.#x();
+				await this.#C();
 			} catch (t) {
 				throw AggregateError([e, t], "Observation stopped after a replacement failed");
 			}
@@ -514,85 +549,82 @@ var F = class {
 			t();
 		}
 	}
-	async #h(e) {
-		if (this.#e.phase !== "active" || M(e)) return;
+	async #_(e) {
+		if (this.#e.phase !== "active" || L(e)) return;
 		let t = this.#e.binding.source.get();
 		if (!(this.#a.present && Object.is(t, this.#a.value))) {
 			try {
-				await this.#v();
+				await this.#b();
 			} catch (e) {
-				throw this.#e.phase === "active" && await this.#x(), e;
+				throw this.#e.phase === "active" && await this.#C(), e;
 			}
-			this.#a = { present: !1 }, !(this.#e.phase !== "active" || M(e)) && this.#g(e);
+			this.#a = { present: !1 }, !(this.#e.phase !== "active" || L(e)) && this.#v(e);
 		}
 	}
-	#g(e) {
-		let { owner: t } = this.#S(), n = t.child("observation");
-		if (this.#n = l(n, "ObservationOwner.child() must return an AsyncDisposable"), e && M(e)) return;
-		let r = this.#S().source.get();
-		e && M(e) || (this.#_(r, n), this.#e.phase === "active" && (this.#a = {
+	#v(e) {
+		let { owner: t } = this.#w(), n = t.child(V);
+		if (this.#n = p(n, "ObservationOwner.child() must return an AsyncDisposable"), e && L(e)) return;
+		let r = this.#w().source.get();
+		e && L(e) || (this.#y(r, n), this.#e.phase === "active" && (this.#a = {
 			present: !0,
 			value: r
 		}));
 	}
-	#_(e, t) {
-		let { observer: n } = this.#S();
-		a(n(e, t), "Observers must be synchronous; use owner.spawn() for async work");
+	#y(e, t) {
+		let { observer: n } = this.#w();
+		c(n(e, t), "Observers must be synchronous; use owner.spawn() for async work");
 	}
-	#v() {
+	#b() {
 		let e = this.#n;
-		if (e) return this.#r ??= Promise.resolve().then(e).then(() => {
+		if (e) return this.#r ??= Promise.resolve().then(() => s(e())).then(() => {
 			this.#n = void 0, this.#r = void 0;
 		});
 	}
-	#y() {
+	#x() {
 		let e = this.#s;
 		return this.#s = void 0, e;
 	}
-	#b(e) {
+	#S(e) {
 		this.#s === e && (this.#s = void 0);
 	}
-	async #x() {
-		this.#C("stopped"), this.#s = void 0;
-		let e = this.#c;
-		e ? await e() : await this.dispose();
+	async #C() {
+		this.#T("stopped"), this.#s = void 0, await this.#p();
 	}
-	#S() {
+	#w() {
 		let e = this.#e;
 		if (e.phase !== "active") throw Error("Observation is not active");
 		return e.binding;
 	}
-	#C(e) {
+	#T(e) {
 		this.#e = { phase: e }, this.#a = { present: !1 }, this.#o = !1;
 	}
 };
-function I(e, t, n) {
-	let r = s(t, "observe()");
+function U(e, t, n) {
+	let r = d(t, "observe()");
 	if (typeof n != "function") throw TypeError("Observer must be a function");
-	let a = e?.defer, o = e?.child, c = e?.spawn;
-	if (typeof a != "function" || typeof o != "function" || typeof c != "function") throw TypeError("observe() expects an observation owner");
-	let u = {
-		defer: (t) => Reflect.apply(a, e, [t]),
-		child: (t) => Reflect.apply(o, e, [t]),
-		spawn: (t) => Reflect.apply(c, e, [t])
-	}, d = new F(u, r, n), f = l(u.defer(() => d.dispose()), "ObservationOwner.defer() must return an AsyncDisposable");
-	d.attachOwnerCleanup(f);
+	let i = e?.defer, a = e?.child, o = e?.spawn;
+	if (typeof i != "function" || typeof a != "function" || typeof o != "function") throw TypeError("observe() expects an observation owner");
+	let c = {
+		defer: (t) => Reflect.apply(i, e, [t]),
+		child: (t) => Reflect.apply(a, e, [t]),
+		spawn: (t) => Reflect.apply(o, e, [t])
+	}, l = new H(c, r, n), u = l.dispose.bind(l);
 	try {
-		return d.start(), Object.freeze({ [i]: f });
+		return u = p(c.defer(u), "ObservationOwner.defer() must return an AsyncDisposable"), l.attachOwnerCleanup(u), l.start(), l.handle;
 	} catch (e) {
 		try {
-			Promise.resolve(f()).catch(() => void 0);
+			s(u()).catch(() => void 0);
 		} catch (t) {
 			throw AggregateError([e, t], "Observation construction failed");
 		}
 		throw e;
 	}
 }
-async function L(e, t) {
+async function W(e, t) {
 	if (e) try {
-		await e();
+		await s(e());
 	} catch (e) {
 		t.push(e);
 	}
 }
-export { T as batch, j as bridge, D as computed, I as observe, E as signal };
+export { i as asyncDisposeSymbol, k as batch, I as bridge, j as computed, r as disposeSymbol, U as observe, A as signal };

package/dist/observe.d.ts

@@ -1,12 +1,13 @@
 import { AsyncDisposable, Readable } from './protocol.js';
-export interface ObservationTask<T = void> extends AsyncDisposable {
-    readonly result: Promise<T>;
+import { SynchronousResult } from './async-result.js';
+export interface ObservationTask extends AsyncDisposable {
+    readonly result: PromiseLike<unknown>;
 }
 export interface ObservationOwner<Child extends AsyncDisposable = AsyncDisposable> {
     readonly defer: (dispose: () => unknown) => AsyncDisposable;
     readonly child: (label: string) => Child;
-    readonly spawn: <T>(task: (signal: AbortSignal) => T | PromiseLike<T>) => ObservationTask<T>;
+    readonly spawn: (task: (signal: AbortSignal) => void | PromiseLike<void>) => ObservationTask;
 }
-export type Observer<T, Child extends AsyncDisposable> = (value: T, lifetime: Child) => void;
-export declare function observe<T, Child extends AsyncDisposable>(owner: ObservationOwner<Child>, source: Readable<T>, observer: Observer<T, Child>): AsyncDisposable;
+export type Observer<T, Child extends AsyncDisposable, Result = void> = (value: T, lifetime: Child) => SynchronousResult<Result>;
+export declare function observe<T, Child extends AsyncDisposable, Result = void>(owner: ObservationOwner<Child>, source: Readable<T>, observer: Observer<T, Child, Result>): 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":"AACA,OAAO,EAKL,KAAK,eAAe,EACpB,KAAK,QAAQ,EACd,MAAM,eAAe,CAAC;AAKvB,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,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,OAAO,KAAK,eAAe,CAAC;IAC5D,QAAQ,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,KAAK,CAAC;IACzC,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;AAoO7F,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,CAiCjB"}
+{"version":3,"file":"observe.d.ts","sourceRoot":"","sources":["../src/observe.ts"],"names":[],"mappings":"AACA,OAAO,EAKL,KAAK,eAAe,EACpB,KAAK,QAAQ,EACd,MAAM,eAAe,CAAC;AACvB,OAAO,EAIL,KAAK,iBAAiB,EACvB,MAAM,mBAAmB,CAAC;AAI3B,MAAM,WAAW,eAAgB,SAAQ,eAAe;IACtD,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;CACvC;AAED,MAAM,WAAW,gBAAgB,CAAC,KAAK,SAAS,eAAe,GAAG,eAAe;IAC/E,QAAQ,CAAC,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,OAAO,KAAK,eAAe,CAAC;IAC5D,QAAQ,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,KAAK,CAAC;IACzC,QAAQ,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI,GAAG,WAAW,CAAC,IAAI,CAAC,KAAK,eAAe,CAAC;CAC9F;AAED,MAAM,MAAM,QAAQ,CAAC,CAAC,EAAE,KAAK,SAAS,eAAe,EAAE,MAAM,GAAG,IAAI,IAAI,CACtE,KAAK,EAAE,CAAC,EACR,QAAQ,EAAE,KAAK,KACZ,iBAAiB,CAAC,MAAM,CAAC,CAAC;AA2P/B,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,SAAS,eAAe,EAAE,MAAM,GAAG,IAAI,EACrE,KAAK,EAAE,gBAAgB,CAAC,KAAK,CAAC,EAC9B,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EACnB,QAAQ,EAAE,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,GACnC,eAAe,CAkCjB"}

package/dist/protocol.d.ts

@@ -1,3 +1,4 @@
+import { SynchronousResult } from './async-result.js';
 export { assertPromiseRuntime, resolveDisposalSymbol, asyncDisposeSymbol, disposeSymbol, } from './disposal-runtime.js';
 export interface Disposable {
     [Symbol.dispose](): void;
@@ -7,7 +8,7 @@ export interface AsyncDisposable {
 }
 export interface Readable<T> {
     get(): T;
-    subscribe(listener: () => void): Disposable;
+    subscribe<Result>(listener: () => SynchronousResult<Result>): Disposable;
 }
 export declare function captureReadable<T>(source: Readable<T>, operation: string): Readable<T>;
 export declare function captureUnsubscribe(subscription: Disposable): () => void;

package/dist/protocol.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../src/protocol.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,oBAAoB,EACpB,qBAAqB,EACrB,kBAAkB,EAClB,aAAa,GACd,MAAM,uBAAuB,CAAC;AAE/B,MAAM,WAAW,UAAU;IACzB,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC;CAC1B;AAED,MAAM,WAAW,eAAe;IAC9B,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,WAAW,CAAC,IAAI,CAAC,CAAC;CAC5C;AAED,MAAM,WAAW,QAAQ,CAAC,CAAC;IACzB,GAAG,IAAI,CAAC,CAAC;IACT,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,UAAU,CAAC;CAC7C;AAED,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,GAAG,QAAQ,CAAC,CAAC,CAAC,CAStF;AAED,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,UAAU,GAAG,MAAM,IAAI,CASvE;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,WAAW,CAAC,IAAI,CAAC,CAI/F;AAQD,wBAAgB,cAAc,CAAC,QAAQ,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,IAAI,MAAM,IAAI,CAIhF"}
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../src/protocol.ts"],"names":[],"mappings":"AACA,OAAO,EAAqB,KAAK,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAE9E,OAAO,EACL,oBAAoB,EACpB,qBAAqB,EACrB,kBAAkB,EAClB,aAAa,GACd,MAAM,uBAAuB,CAAC;AAE/B,MAAM,WAAW,UAAU;IACzB,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC;CAC1B;AAED,MAAM,WAAW,eAAe;IAC9B,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,WAAW,CAAC,IAAI,CAAC,CAAC;CAC5C;AAED,MAAM,WAAW,QAAQ,CAAC,CAAC;IACzB,GAAG,IAAI,CAAC,CAAC;IACT,SAAS,CAAC,MAAM,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC,MAAM,CAAC,GAAG,UAAU,CAAC;CAC1E;AAED,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,GAAG,QAAQ,CAAC,CAAC,CAAC,CAStF;AAED,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,UAAU,GAAG,MAAM,IAAI,CASvE;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,WAAW,CAAC,IAAI,CAAC,CAI/F;AAQD,wBAAgB,cAAc,CAAC,QAAQ,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,IAAI,MAAM,IAAI,CAIhF"}

package/dist/signals.d.ts

@@ -1,4 +1,5 @@
 import { Readable } from './protocol.js';
+import { SynchronousResult } from './async-result.js';
 declare const dougongSignal: unique symbol;
 export interface ReadonlySignal<T> extends Readable<T> {
     readonly [dougongSignal]: true;
@@ -6,8 +7,8 @@ export interface ReadonlySignal<T> extends Readable<T> {
 export interface Signal<T> extends ReadonlySignal<T> {
     readonly set: (value: T) => void;
 }
-export declare function batch<T>(callback: () => T): T;
+export declare function batch<T>(callback: () => SynchronousResult<T>): T;
 export declare function signal<T>(initialValue: T): Signal<T>;
-export declare function computed<T>(calculate: () => T): ReadonlySignal<T>;
+export declare function computed<T>(calculate: () => SynchronousResult<T>): ReadonlySignal<T>;
 export {};
 //# sourceMappingURL=signals.d.ts.map

package/dist/signals.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"signals.d.ts","sourceRoot":"","sources":["../src/signals.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkD,KAAK,QAAQ,EAAE,MAAM,eAAe,CAAC;AAG9F,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;AAgHD,wBAAgB,KAAK,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC,CAgC7C;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"}
+{"version":3,"file":"signals.d.ts","sourceRoot":"","sources":["../src/signals.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkD,KAAK,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9F,OAAO,EAAqB,KAAK,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAE9E,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;AAgHD,wBAAgB,KAAK,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC,CAAC,CAAC,GAAG,CAAC,CAgChE;AAED,wBAAgB,MAAM,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAEpD;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAGpF"}

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@dougongjs/reactive",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "type": "module",
   "engines": {
-    "node": ">=22"
+    "node": "^24.22.0 || >=26.10.0"
   },
   "browserslist": [
     "Chrome >= 119",
@@ -27,8 +27,7 @@
   "imports": {
     "#abort-listener": {
       "types": "./runtime/abort-listener.d.mts",
-      "node": "./runtime/abort-listener.node.mjs",
-      "default": "./runtime/abort-listener.web.mjs"
+      "default": "./runtime/abort-listener.mjs"
     }
   },
   "description": "Zero-dependency signal, computed, batch and observe primitives.",

package/runtime/abort-listener.d.mts

@@ -1,2 +1,3 @@
 // Generated from tooling/internal/abort-listener.d.mts. Run pnpm generate:internal.
+export function assertAbortRuntime(any: unknown): void;
 export function listenForAbort(signal: AbortSignal, notify: () => void): () => void;

package/runtime/abort-listener.mjs

@@ -0,0 +1,45 @@
+// Generated from tooling/internal/abort-listener.mjs. Run pnpm generate:internal.
+// The private dependent must take its state from the source's controller. A runtime whose
+// AbortSignal.any reads the public, shadowable properties instead would create a dependent
+// already aborted with a forged reason, which never reports the real cancellation.
+export function assertAbortRuntime(any) {
+  if (typeof any !== "function") {
+    throw new Error("Unsupported JavaScript runtime: AbortSignal.any is required");
+  }
+  const source = new AbortController().signal;
+  Object.defineProperty(source, "aborted", { value: true });
+  if (Reflect.get(AbortSignal.prototype, "aborted", any.call(AbortSignal, [source]))) {
+    throw new Error(
+      "Unsupported JavaScript runtime: AbortSignal.any must read native signal state",
+    );
+  }
+}
+
+assertAbortRuntime(AbortSignal.any);
+
+// A separate closure prevents the dependent from retaining the source through its registration.
+function weakAbortListener(reference) {
+  return () => reference.deref()?.();
+}
+
+export function listenForAbort(signal, notify) {
+  const dependent = AbortSignal.any([signal]);
+  const listener = weakAbortListener(new WeakRef(notify));
+  let registration = { signal, notify, dependent, listener };
+  function detach() {
+    if (!registration) return;
+    const attached = registration;
+    registration = undefined;
+    EventTarget.prototype.removeEventListener.call(attached.signal, "abort", attached.notify);
+    attached.dependent.removeEventListener("abort", attached.listener);
+  }
+  try {
+    // Source listeners preserve native composite lifetimes; the private dependent bypasses stopped events.
+    EventTarget.prototype.addEventListener.call(signal, "abort", notify);
+    dependent.addEventListener("abort", listener);
+  } catch (error) {
+    detach();
+    throw error;
+  }
+  return detach;
+}

package/dist/synchronous-result.d.ts

@@ -1,3 +0,0 @@
-export declare function assertSynchronous(value: unknown, message: string): void;
-export declare function captureThenable(value: unknown): Promise<unknown> | undefined;
-//# sourceMappingURL=synchronous-result.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"synchronous-result.d.ts","sourceRoot":"","sources":["../src/synchronous-result.ts"],"names":[],"mappings":"AACA,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAUvE;AAGD,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,SAAS,CAa5E"}

package/runtime/abort-listener.node.mjs

@@ -1,26 +0,0 @@
-// Generated from tooling/internal/abort-listener.node.mjs. Run pnpm generate:internal.
-import { addAbortListener } from "node:events";
-
-export function listenForAbort(signal, notify) {
-  // Node supplies stop-resistant listener options to this private registration signal.
-  // The caller's genuine EventTarget owns the actual listener and its native GC bookkeeping.
-  const registration = new AbortController().signal;
-  let detach;
-  registration.addEventListener = (type, listener, options) => {
-    detach = () => EventTarget.prototype.removeEventListener.call(signal, type, listener);
-    try {
-      // Only native cancellation may consume the listener. Synthetic abort events can arrive first.
-      EventTarget.prototype.addEventListener.call(signal, type, listener, {
-        ...options,
-        once: false,
-      });
-    } catch (error) {
-      // A native listener hook may throw before or after insertion.
-      detach();
-      throw error;
-    }
-  };
-  addAbortListener(registration, notify);
-  if (!detach) throw new Error("Node did not attach the protected abort listener");
-  return detach;
-}

package/runtime/abort-listener.web.mjs

@@ -1,7 +0,0 @@
-// Generated from tooling/internal/abort-listener.web.mjs. Run pnpm generate:internal.
-// Only the controller can abort this private dependent; other listeners can stop propagation on the source.
-export function listenForAbort(signal, notify) {
-  const dependent = AbortSignal.any([signal]);
-  dependent.addEventListener("abort", notify);
-  return () => dependent.removeEventListener("abort", notify);
-}