@dougongjs/reactive 0.8.2 → 0.9.0

package/README.md

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

package/dist/abort.d.ts

@@ -0,0 +1,4 @@
+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;
+//# sourceMappingURL=abort.d.ts.map

package/dist/abort.d.ts.map

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

package/dist/bridge.d.ts

@@ -0,0 +1,7 @@
+import { AsyncDisposable, Readable } from './protocol.js';
+import { ReadonlySignal } from './signals.js';
+export interface BridgeOwner {
+    readonly defer: (dispose: () => unknown) => AsyncDisposable;
+}
+export declare function bridge<T>(owner: BridgeOwner, source: Readable<T>): ReadonlySignal<T>;
+//# sourceMappingURL=bridge.d.ts.map

package/dist/bridge.d.ts.map

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

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-export { batch, computed, signal, type ReadonlySignal, type Signal } from './signals';
-export type { AsyncDisposable, Disposable, Readable } from './protocol';
-export { observe, type ObservationOwner, type ObservationTask, type Observer } from './observe';
+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 { 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,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"}
+{"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"}

package/dist/index.js

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

package/dist/observe.d.ts

@@ -1,10 +1,10 @@
-import { AsyncDisposable, Readable } from './protocol';
+import { AsyncDisposable, Readable } from './protocol.js';
 export interface ObservationTask<T = void> extends AsyncDisposable {
     readonly result: Promise<T>;
 }
 export interface ObservationOwner<Child extends AsyncDisposable = AsyncDisposable> {
-    readonly cleanup: (dispose: () => unknown) => AsyncDisposable;
-    readonly lifetime: (label: string) => Child;
+    readonly defer: (dispose: () => unknown) => AsyncDisposable;
+    readonly child: (label: string) => Child;
     readonly spawn: <T>(task: (signal: AbortSignal) => T | PromiseLike<T>) => ObservationTask<T>;
 }
 export type Observer<T, Child extends AsyncDisposable> = (value: T, lifetime: Child) => void;

package/dist/observe.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"observe.d.ts","sourceRoot":"","sources":["../src/observe.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,eAAe,EAEpB,KAAK,QAAQ,EACd,MAAM,YAAY,CAAC;AAKpB,MAAM,WAAW,eAAe,CAAC,CAAC,GAAG,IAAI,CAAE,SAAQ,eAAe;IAChE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;CAC7B;AAED,MAAM,WAAW,gBAAgB,CAAC,KAAK,SAAS,eAAe,GAAG,eAAe;IAC/E,QAAQ,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,MAAM,OAAO,KAAK,eAAe,CAAC;IAC9D,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,KAAK,CAAC;IAC5C,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,KAAK,eAAe,CAAC,CAAC,CAAC,CAAC;CAC9F;AAED,MAAM,MAAM,QAAQ,CAAC,CAAC,EAAE,KAAK,SAAS,eAAe,IAAI,CAAC,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,KAAK,KAAK,IAAI,CAAC;AAgN7F,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,SAAS,eAAe,EACtD,KAAK,EAAE,gBAAgB,CAAC,KAAK,CAAC,EAC9B,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EACnB,QAAQ,EAAE,QAAQ,CAAC,CAAC,EAAE,KAAK,CAAC,GAC3B,eAAe,CAyBjB"}
+{"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"}

package/dist/protocol.d.ts

@@ -1,14 +1,16 @@
-export { assertPromiseRuntime, resolveDisposalSymbol, asyncDisposeSymbol, disposeSymbol, } from './disposal-runtime';
+export { assertPromiseRuntime, resolveDisposalSymbol, asyncDisposeSymbol, disposeSymbol, } from './disposal-runtime.js';
 export interface Disposable {
-    dispose(): void;
     [Symbol.dispose](): void;
 }
 export interface AsyncDisposable {
-    dispose(): Promise<void>;
-    [Symbol.asyncDispose](): Promise<void>;
+    [Symbol.asyncDispose](): PromiseLike<void>;
 }
 export interface Readable<T> {
     get(): T;
     subscribe(listener: () => void): Disposable;
 }
+export declare function captureReadable<T>(source: Readable<T>, operation: string): Readable<T>;
+export declare function captureUnsubscribe(subscription: Disposable): () => void;
+export declare function captureRelease(value: AsyncDisposable, message: string): () => PromiseLike<void>;
+export declare function assertListener(listener: unknown): asserts listener is () => void;
 //# sourceMappingURL=protocol.d.ts.map

package/dist/protocol.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../src/protocol.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,qBAAqB,EACrB,kBAAkB,EAClB,aAAa,GACd,MAAM,oBAAoB,CAAC;AAE5B,MAAM,WAAW,UAAU;IACzB,OAAO,IAAI,IAAI,CAAC;IAChB,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC;CAC1B;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACzB,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxC;AAED,MAAM,WAAW,QAAQ,CAAC,CAAC;IACzB,GAAG,IAAI,CAAC,CAAC;IACT,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,UAAU,CAAC;CAC7C"}
+{"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"}

package/dist/signals.d.ts

@@ -1,4 +1,4 @@
-import { Readable } from './protocol';
+import { Readable } from './protocol.js';
 declare const dougongSignal: unique symbol;
 export interface ReadonlySignal<T> extends Readable<T> {
     readonly [dougongSignal]: true;

package/dist/signals.d.ts.map

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

package/dist/{sync-result.d.ts → synchronous-result.d.ts}

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

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

@@ -0,0 +1 @@
+{"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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dougongjs/reactive",
-  "version": "0.8.2",
+  "version": "0.9.0",
   "type": "module",
   "engines": {
     "node": ">=22"
@@ -8,12 +8,13 @@
   "browserslist": [
     "Chrome >= 119",
     "Edge >= 119",
-    "Firefox >= 121",
+    "Firefox >= 124",
     "Safari >= 17.4"
   ],
   "sideEffects": false,
   "files": [
     "dist",
+    "runtime",
     "README.md",
     "LICENSE"
   ],
@@ -23,6 +24,13 @@
       "import": "./dist/index.js"
     }
   },
+  "imports": {
+    "#abort-listener": {
+      "types": "./runtime/abort-listener.d.mts",
+      "node": "./runtime/abort-listener.node.mjs",
+      "default": "./runtime/abort-listener.web.mjs"
+    }
+  },
   "description": "Zero-dependency signal, computed, batch and observe primitives.",
   "license": "MIT",
   "author": "Dougong contributors",
@@ -47,6 +55,6 @@
     "access": "public"
   },
   "scripts": {
-    "build": "node ../../scripts/generate-internal.mjs && vite build"
+    "build": "node ../../tooling/generate-internal.mjs && vite build"
   }
 }

package/runtime/abort-listener.d.mts

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

package/runtime/abort-listener.node.mjs

@@ -0,0 +1,26 @@
+// 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

@@ -0,0 +1,7 @@
+// 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);
+}

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

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