@dougongjs/reactive 0.8.3 → 0.10.0

package/dist/index.js

@@ -1,406 +1,626 @@
-function D(s) {
-  if (typeof s != "function")
-    throw new Error("Unsupported JavaScript runtime: Promise.withResolvers is required");
+import { listenForAbort as e } from "#abort-listener";
+// src/disposal-runtime.ts
+function t(e) {
+	if (typeof e != "function") throw Error("Unsupported JavaScript runtime: Promise.withResolvers is required");
 }
-function b(s, e) {
-  return s ?? Symbol.for(e);
+function n(e, t) {
+	return e ?? Symbol.for(t);
 }
-D(Promise.withResolvers);
-const w = b(
-  Symbol.dispose,
-  "Symbol.dispose"
-), y = b(
-  Symbol.asyncDispose,
-  "Symbol.asyncDispose"
-);
-function a(s, e) {
-  const t = m(s);
-  if (t)
-    throw t.catch(() => {
-    }), new TypeError(e);
+t(Promise.withResolvers);
+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 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((t, i) => Reflect.apply(e, s, [t, i]))
-    );
+function c(e, t) {
+	let n = l(e);
+	if (n) throw n.then(() => void 0, () => void 0), TypeError(t);
 }
-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);
-  }
-  dispose() {
-    const e = this.#e;
-    this.#e = void 0, e?.();
-  }
-  [w]() {
-    this.dispose();
-  }
+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();
+	return queueMicrotask(() => {
+		try {
+			Reflect.apply(t, e, [n.resolve, n.reject]);
+		} catch (e) {
+			n.reject(e);
+		}
+	}), n.promise.then((e) => Object.freeze({ value: e }));
 }
-function O() {
-  if (p) return;
-  const s = [];
-  p = !0;
-  try {
-    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 {
-          a(i(), "Signal subscribers must be synchronous");
-        } catch (r) {
-          s.push(r);
-        }
-    }
-  } finally {
-    f.clear(), o.clear(), p = !1;
-  }
-  R(s);
+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;
 }
-function S(s) {
-  for (const e of s)
-    (e.kind === "dependency" ? o : f).add(e);
-  u || O();
+// src/protocol.ts
+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({
+		get: () => Reflect.apply(n, e, []),
+		subscribe: (t) => Reflect.apply(r, e, [t])
+	});
 }
-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 f(e) {
+	let t = e?.[r];
+	return typeof t != "function" && m(e, "Readable.subscribe() must return a Disposable"), () => c(Reflect.apply(t, e, []), "Readable subscriptions must dispose synchronously");
 }
-function R(s) {
-  if (s.length === 1) throw s[0];
-  if (s.length > 1)
-    throw new AggregateError(s, "Reactive subscribers failed");
+function p(e, t) {
+	let n = e?.[i];
+	return typeof n != "function" && m(e, t), () => Reflect.apply(n, e, []);
 }
-function E(s) {
-  c?.(s);
+function m(e, t) {
+	throw c(e, t), TypeError(t);
 }
-function I(s) {
-  if (typeof s != "function") throw new TypeError("batch() expects a function");
-  u++;
-  let e;
-  try {
-    const t = s();
-    a(t, "Reactive batches must be synchronous"), e = { ok: !0, value: t };
-  } catch (t) {
-    e = { ok: !1, error: t };
-  } finally {
-    u--;
-  }
-  if (!u)
-    try {
-      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 h(e) {
+	if (typeof e != "function") throw TypeError("Signal subscriber must be a function");
 }
-function L(s) {
-  return new z(s).view;
-}
-function q(s) {
-  if (typeof s != "function") throw new TypeError("computed() expects a function");
-  return new P(s).view;
+// src/signals.ts
+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);
+	}
+	[r]() {
+		let e = this.#e;
+		this.#e = void 0, e?.();
+	}
+};
+function T() {
+	if (v) return;
+	let e = [];
+	v = !0;
+	try {
+		for (; b.size;) {
+			let t = b.values().next().value;
+			b.delete(t);
+			let n = t.listener;
+			if (n) try {
+				c(n(), "Signal subscribers must be synchronous");
+			} catch (t) {
+				e.push(t);
+			}
+		}
+	} finally {
+		b.clear(), v = !1;
+	}
+	O(e);
 }
-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));
-  }
+function E(e) {
+	for (let t of e) (t.kind === "dependency" ? x : b).add(t);
+	if (!y) {
+		y = !0;
+		try {
+			for (; x.size;) {
+				let e = x.values().next().value;
+				x.delete(e);
+				let t = e.listener;
+				t?.();
+			}
+		} finally {
+			y = !1, x.clear();
+		}
+		_ || T();
+	}
 }
-class P {
-  #e;
-  #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: (t) => this.#h(t)
-    }), l.set(this.view, this);
-  }
-  get version() {
-    return this.#c;
-  }
-  refresh() {
-    if (this.#n) throw new TypeError("Circular computed signal");
-    this.#n = !0;
-    try {
-      this.#v();
-    } finally {
-      this.#n = !1;
-    }
-  }
-  #o() {
-    return this.refresh(), E(this.view), this.#a();
-  }
-  #a() {
-    const e = this.#r;
-    if (e.phase === "error") throw e.error;
-    return e.value;
-  }
-  subscribeInvalidation(e) {
-    return this.#h(e, "dependency");
-  }
-  #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(), t === "observer" && this.#a(), this.#f();
-      } catch (n) {
-        throw this.#t.delete(i), this.#t.size || this.#u(), n;
-      }
-    return new g(() => {
-      i.listener = void 0, this.#t.delete(i), this.#t.size || this.#u();
-    });
-  }
-  #d = () => {
-    this.#i || (this.#i = !0, S(this.#t));
-  };
-  #u() {
-    for (const e of this.#s.values())
-      e.subscription?.dispose(), e.subscription = void 0;
-  }
-  #f() {
-    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 i = this.#e();
-      return a(i, "Computed signal calculations must be synchronous"), { phase: "value", value: i };
-    } catch (i) {
-      return { phase: "error", error: i };
-    } finally {
-      c = t;
-    }
-  }
-  #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
-      };
-      r.version = i.version, this.#s.set(t, r);
-    }
-  }
+function D(e, t, n) {
+	h(t);
+	let r = {
+		kind: n,
+		listener: t
+	};
+	return e.add(r), new w(() => {
+		r.listener = void 0, e.delete(r);
+	});
 }
-function k(s) {
-  if (typeof s != "function")
-    throw new TypeError("Signal subscriber must be a function");
+function O(e) {
+	if (e.length === 1) throw e[0];
+	if (e.length > 1) throw AggregateError(e, "Reactive subscribers failed");
 }
-class j {
-  #e;
-  #t;
-  #s;
-  #r = { present: !1 };
-  #n = !1;
-  #i;
-  #c;
-  #o;
-  #a;
-  constructor(e, t, i) {
-    this.#e = { phase: "active", binding: { owner: e, source: t, observer: i } };
-  }
-  start() {
-    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) {
-    this.#c = e;
-  }
-  dispose() {
-    if (this.#a) return this.#a;
-    const e = Promise.withResolvers();
-    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.#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");
-  }
-  #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.#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.#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), t();
-      };
-      this.#o = i, e.addEventListener("abort", i, { once: !0 }), (this.#n || this.#e.phase !== "active" || e.aborted) && i();
-    });
-  }
-  // 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 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();
-  }
-  #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 {
-        v(t);
-      } catch (i) {
-        e.push(i);
-      }
-  }
-  #w() {
-    const e = this.#s;
-    return this.#s = void 0, e;
-  }
-  #O() {
-    const e = this.#i;
-    return this.#i = void 0, e;
-  }
-  #S() {
-    const e = this.#c;
-    return this.#c = void 0, e;
-  }
-  #m(e) {
-    this.#i === e && (this.#i = void 0);
-  }
-  async #E(e) {
-    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");
-  }
-  #y() {
-    const e = this.#e;
-    if (e.phase !== "active") throw new Error("Observation is not active");
-    return e.binding;
-  }
-  #g(e) {
-    this.#e = { phase: e }, this.#r = { present: !1 }, this.#n = !1;
-  }
+function k(e) {
+	if (typeof e != "function") throw TypeError("batch() expects a function");
+	_++;
+	let t;
+	try {
+		let n = e();
+		c(n, "Reactive batches must be synchronous"), t = {
+			succeeded: !0,
+			value: n
+		};
+	} catch (e) {
+		t = {
+			succeeded: !1,
+			error: e
+		};
+	} finally {
+		_--;
+	}
+	if (!_) try {
+		T();
+	} catch (e) {
+		t = t.succeeded ? {
+			succeeded: !1,
+			error: e
+		} : {
+			succeeded: !1,
+			error: AggregateError([t.error, e], "Reactive batch failed")
+		};
+	}
+	if (!t.succeeded) throw t.error;
+	return t.value;
 }
-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 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 j(s, e, t), r = s.cleanup(() => i.dispose());
-  T(r, "ObservationOwner.cleanup()"), i.attachOwnerCleanup(r);
-  try {
-    return i.start(), r;
-  } catch (n) {
-    throw i.dispose().catch(() => {
-    }), n;
-  }
+function A(e) {
+	return new M(e).view;
 }
-function x(s, e) {
-  if (!s || typeof s.dispose != "function" || typeof s[w] != "function")
-    throw new TypeError(`${e} must return a Disposable`);
+function j(e) {
+	if (typeof e != "function") throw TypeError("computed() expects a function");
+	return new N(e).view;
 }
-function T(s, e) {
-  if (!s || typeof s.dispose != "function" || typeof s[y] != "function")
-    throw new TypeError(`${e} must return an AsyncDisposable`);
+var M = class {
+	#e = /* @__PURE__ */ new Set();
+	#t;
+	#n = 0;
+	view;
+	constructor(e) {
+		this.#t = e, this.view = Object.freeze({
+			get: () => (S?.add(this), this.#t),
+			set: (e) => this.#r(e),
+			subscribe: (e) => D(this.#e, e, "observer")
+		});
+	}
+	get version() {
+		return this.#n;
+	}
+	refresh() {}
+	subscribeInvalidation(e) {
+		return D(this.#e, e, "dependency");
+	}
+	#r(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));
+	}
+}, N = class e {
+	#e;
+	#t = /* @__PURE__ */ new Set();
+	#n = /* @__PURE__ */ new Map();
+	#r;
+	#i = -1;
+	#a;
+	#o;
+	#s = -1;
+	#c = 0;
+	view;
+	constructor(e) {
+		this.#e = e, this.view = Object.freeze({
+			get: () => this.#u(),
+			subscribe: (e) => this.#f(e)
+		});
+	}
+	get version() {
+		return this.#c;
+	}
+	refresh() {
+		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 {
+			C.pop(), this.#a = void 0;
+		}
+	}
+	#l(t, n) {
+		let r = /* @__PURE__ */ new Set();
+		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(), S?.add(this), this.#d();
+	}
+	#d() {
+		let e = this.#r;
+		if (e.phase === "error") throw e.error;
+		return e.value;
+	}
+	subscribeInvalidation(e) {
+		return this.#f(e, "dependency");
+	}
+	#f(e, t = "observer") {
+		h(e);
+		let n = {
+			kind: t,
+			listener: e
+		}, r = this.#t.size === 0;
+		if (this.#t.add(n), r || t === "observer") try {
+			this.refresh(), t === "observer" && this.#d(), r && this.#h();
+		} catch (e) {
+			throw this.#t.delete(n), this.#t.size || this.#m(), e;
+		}
+		return new w(() => {
+			n.listener = void 0, this.#t.delete(n), this.#t.size || this.#m();
+		});
+	}
+	#p = () => {
+		this.#s !== g && (this.#s = g, E(this.#t));
+	};
+	#m() {
+		for (let e of this.#n.values()) e.subscription?.[r](), e.subscription = void 0;
+	}
+	#h() {
+		for (let [e, t] of this.#n) t.subscription ??= e.subscribeInvalidation(this.#p);
+	}
+	#g() {
+		let e = this.#r;
+		if (e && this.#s <= this.#i && (this.#i === g || !this.#_())) {
+			this.#i = g;
+			return;
+		}
+		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 = 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 > this.#i;
+	}
+	#v(e) {
+		let t = S;
+		this.#o = e, S = e;
+		try {
+			let e = this.#e, t = e();
+			return c(t, "Computed signal calculations must be synchronous"), {
+				phase: "value",
+				value: t
+			};
+		} catch (e) {
+			return {
+				phase: "error",
+				error: e
+			};
+		} finally {
+			S = t, this.#o = void 0;
+		}
+	}
+	#y(e) {
+		for (let [t, n] of this.#n) e.has(t) || (n.subscription?.[r](), this.#n.delete(t));
+		for (let t of e) {
+			let e = this.#n.get(t);
+			e ? e.version = t.version : this.#n.set(t, {
+				version: t.version,
+				subscription: void 0
+			});
+		}
+	}
+}, P = class {
+	#e;
+	#t;
+	#n;
+	#r;
+	view;
+	constructor(e) {
+		this.#e = A({
+			phase: "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;
+				return e.value;
+			},
+			subscribe: (e) => this.#o(e)
+		});
+	}
+	start(e) {
+		let t = !0, n;
+		try {
+			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 = 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");
+			}
+			this.#a(), this.view.get();
+		} catch (e) {
+			let t = n;
+			throw t && Promise.resolve().then(() => s(t())).catch(() => void 0), e;
+		} finally {
+			t = !1;
+		}
+	}
+	#i() {
+		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;
+			try {
+				r = {
+					phase: "value",
+					source: n,
+					value: n.get()
+				};
+			} catch (e) {
+				r = {
+					phase: "error",
+					source: n,
+					error: e
+				};
+			}
+			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");
+		h(e);
+		let n = t.subscribe(() => (this.#e?.get() || n[r](), e()));
+		return n;
+	}
+	[r]() {
+		let e = this.#e;
+		if (!e?.get()) return this.#i();
+		let t = [];
+		try {
+			e.set(void 0);
+		} catch (n) {
+			if (e.get()) throw n;
+			t.push(n);
+		}
+		this.#e = void 0;
+		try {
+			this.#t?.(), this.#t = void 0;
+		} catch (e) {
+			t.push(e);
+		}
+		if (t.length) {
+			let e = t.length === 1 ? t[0] : AggregateError(t, "Readable bridge cleanup failed");
+			throw this.#r = { value: e }, e;
+		}
+	}
+};
+function F(e, t) {
+	let n = e?.defer;
+	if (typeof n != "function") throw TypeError("bridge() expects a resource owner");
+	let i = d(t, "bridge()"), a = { defer: (t) => Reflect.apply(n, e, [t]) }, o = new P(i);
+	try {
+		return o.start(a), o.view;
+	} catch (e) {
+		try {
+			o[r]();
+		} catch (t) {
+			throw AggregateError([e, t], "Readable bridge construction failed");
+		}
+		throw e;
+	}
 }
-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;
+// src/abort.ts
+function I(e) {
+	return Reflect.get(AbortSignal.prototype, "aborted", e);
 }
-function v(s) {
-  a(s.dispose(), "Readable subscriptions must dispose synchronously");
+function L(e) {
+	return Reflect.get(AbortSignal.prototype, "reason", e);
 }
-async function h(s, e) {
-  if (s)
-    try {
-      await s.dispose();
-    } catch (t) {
-      e.push(t);
-    }
+function R(t, n) {
+	if (typeof n != "function") throw TypeError("Abort listener must be a function");
+	if (I(t)) return n(L(t)), () => {};
+	let r = {
+		signal: t,
+		callback: n
+	}, i;
+	function a() {
+		r = void 0, i?.(), i = void 0;
+	}
+	function o() {
+		if (!r || !I(r.signal)) return;
+		let { signal: e, callback: t } = r, n = L(e);
+		a(), t(n);
+	}
+	return i = e(t, o), r ? o() : a(), a;
 }
-export {
-  I as batch,
-  q as computed,
-  B as observe,
-  L as signal
+// src/observe.ts
+var z = class {
+	#e;
+	#t;
+	#n;
+	#r;
+	#i = !1;
+	#a = { present: !1 };
+	#o = !1;
+	#s;
+	#c;
+	#l;
+	#u;
+	#d;
+	constructor(e, t, n) {
+		this.#e = {
+			phase: "active",
+			binding: {
+				owner: e,
+				source: t,
+				observer: n
+			}
+		};
+	}
+	start() {
+		this.#i = !0;
+		try {
+			this.#f();
+		} finally {
+			this.#i = !1;
+		}
+	}
+	#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 = l(n.result);
+		if (!i) throw TypeError("ObservationOwner.spawn() must return an ObservationTask");
+		i.then(() => this.#S(r), () => this.#S(r));
+	}
+	attachOwnerCleanup(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.#d) return this.#d;
+		let e = Promise.withResolvers();
+		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 #m() {
+		let e = [];
+		try {
+			this.#t?.(), this.#t = void 0;
+		} catch (t) {
+			e.push(t);
+		}
+		await V(this.#x(), e);
+		try {
+			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");
+	}
+	#h() {
+		this.#e.phase === "active" && (this.#o = !0, this.#u?.());
+	}
+	async #g(e) {
+		let t = R(e, () => this.#u?.());
+		try {
+			for (; this.#e.phase === "active" && !I(e);) {
+				if (!this.#o) {
+					let e = Promise.withResolvers();
+					this.#u = e.resolve, await e.promise, this.#u = void 0;
+				}
+				for (; this.#e.phase === "active" && !I(e) && this.#o;) this.#o = !1, await this.#_(e);
+			}
+		} catch (e) {
+			if (this.#e.phase !== "active") throw e;
+			try {
+				await this.#C();
+			} catch (t) {
+				throw AggregateError([e, t], "Observation stopped after a replacement failed");
+			}
+			throw e;
+		} finally {
+			t();
+		}
+	}
+	async #_(e) {
+		if (this.#e.phase !== "active" || I(e)) return;
+		let t = this.#e.binding.source.get();
+		if (!(this.#a.present && Object.is(t, this.#a.value))) {
+			try {
+				await this.#b();
+			} catch (e) {
+				throw this.#e.phase === "active" && await this.#C(), e;
+			}
+			this.#a = { present: !1 }, !(this.#e.phase !== "active" || I(e)) && this.#v(e);
+		}
+	}
+	#v(e) {
+		let { owner: t } = this.#w(), n = t.child("observation");
+		if (this.#n = p(n, "ObservationOwner.child() must return an AsyncDisposable"), e && I(e)) return;
+		let r = this.#w().source.get();
+		e && I(e) || (this.#y(r, n), this.#e.phase === "active" && (this.#a = {
+			present: !0,
+			value: r
+		}));
+	}
+	#y(e, t) {
+		let { observer: n } = this.#w();
+		c(n(e, t), "Observers must be synchronous; use owner.spawn() for async work");
+	}
+	#b() {
+		let e = this.#n;
+		if (e) return this.#r ??= Promise.resolve().then(() => s(e())).then(() => {
+			this.#n = void 0, this.#r = void 0;
+		});
+	}
+	#x() {
+		let e = this.#s;
+		return this.#s = void 0, e;
+	}
+	#S(e) {
+		this.#s === e && (this.#s = void 0);
+	}
+	async #C() {
+		this.#T("stopped"), this.#s = void 0, await this.#p();
+	}
+	#w() {
+		let e = this.#e;
+		if (e.phase !== "active") throw Error("Observation is not active");
+		return e.binding;
+	}
+	#T(e) {
+		this.#e = { phase: e }, this.#a = { present: !1 }, this.#o = !1;
+	}
 };
+function B(e, t, n) {
+	let r = d(t, "observe()");
+	if (typeof n != "function") throw TypeError("Observer must be a function");
+	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 z(c, r, n), u = p(c.defer(() => l.dispose()), "ObservationOwner.defer() must return an AsyncDisposable");
+	l.attachOwnerCleanup(u);
+	try {
+		return l.start(), l.handle;
+	} catch (e) {
+		try {
+			s(u()).catch(() => void 0);
+		} catch (t) {
+			throw AggregateError([e, t], "Observation construction failed");
+		}
+		throw e;
+	}
+}
+async function V(e, t) {
+	if (e) try {
+		await s(e());
+	} catch (e) {
+		t.push(e);
+	}
+}
+export { i as asyncDisposeSymbol, k as batch, F as bridge, j as computed, r as disposeSymbol, B as observe, A as signal };