@ably/ai-transport 0.0.1 → 0.1.0

package/dist/react/ably-ai-transport-react.js

@@ -1,92 +1,72 @@
-import { useCallback as e, useEffect as t, useRef as n, useState as r } from "react";
-import * as i from "ably";
-//#region src/react/use-ably-messages.ts
-var a = (e) => {
-	let [n, i] = r(() => e.getAblyMessages());
-	return t(() => (i(e.getAblyMessages()), e.on("ably-message", () => {
-		i(e.getAblyMessages());
-	})), [e]), n;
-}, o = "x-ably-turn-id", s = "x-ably-msg-id", c = "x-ably-turn-client-id", l = "x-ably-role", u = "x-ably-cancel-turn-id", d = "x-ably-cancel-own", f = "x-ably-cancel-all", p = "x-ably-cancel-client-id", m = "x-ably-parent", h = "x-ably-fork-of", g = "x-ably-cancel", _ = "x-ably-turn-start", v = "x-ably-turn-end", y = (e) => {
-	let [n, i] = r(() => /* @__PURE__ */ new Map());
-	return t(() => {
-		if (e) return i(e.getActiveTurnIds()), e.on("turn", (e) => {
-			i((t) => {
-				let n = new Map(t);
-				if (e.type === "x-ably-turn-start") {
-					let t = new Set(n.get(e.clientId) ?? []);
-					t.add(e.turnId), n.set(e.clientId, t);
-				} else {
-					let t = n.get(e.clientId);
-					t && (t.delete(e.turnId), t.size === 0 ? n.delete(e.clientId) : n.set(e.clientId, new Set(t)));
-				}
-				return n;
-			});
-		});
-	}, [e]), n;
-}, b = /* @__PURE__ */ function(e) {
-	return e[e.BadRequest = 4e4] = "BadRequest", e[e.InvalidArgument = 40003] = "InvalidArgument", e[e.EncoderRecoveryFailed = 104e3] = "EncoderRecoveryFailed", e[e.TransportSubscriptionError = 104001] = "TransportSubscriptionError", e[e.CancelListenerError = 104002] = "CancelListenerError", e[e.TurnLifecycleError = 104003] = "TurnLifecycleError", e[e.TransportClosed = 104004] = "TransportClosed", e[e.TransportSendFailed = 104005] = "TransportSendFailed", e;
-}({}), x = (e) => ({
+import { createContext as e, useCallback as t, useContext as n, useEffect as r, useMemo as i, useRef as a, useState as o } from "react";
+import * as s from "ably";
+import { ChannelProvider as c, useChannel as l } from "ably/react";
+import { jsx as u } from "react/jsx-runtime";
+//#region src/react/contexts/transport-context.ts
+var d = e({}), f = e(void 0), p = "x-ably-status", m = "x-ably-turn-id", h = "x-ably-msg-id", g = "x-ably-turn-client-id", _ = "x-ably-role", v = "x-ably-amend", y = "x-ably-cancel-turn-id", b = "x-ably-cancel-own", x = "x-ably-cancel-all", S = "x-ably-cancel-client-id", C = "x-ably-parent", w = "x-ably-fork-of", T = "x-ably-cancel", E = "x-ably-turn-start", D = "x-ably-turn-end", O = /* @__PURE__ */ function(e) {
+	return e[e.BadRequest = 4e4] = "BadRequest", e[e.InvalidArgument = 40003] = "InvalidArgument", e[e.EncoderRecoveryFailed = 104e3] = "EncoderRecoveryFailed", e[e.TransportSubscriptionError = 104001] = "TransportSubscriptionError", e[e.CancelListenerError = 104002] = "CancelListenerError", e[e.TurnLifecycleError = 104003] = "TurnLifecycleError", e[e.TransportClosed = 104004] = "TransportClosed", e[e.TransportSendFailed = 104005] = "TransportSendFailed", e[e.ChannelContinuityLost = 104006] = "ChannelContinuityLost", e[e.ChannelNotReady = 104007] = "ChannelNotReady", e[e.StreamError = 104008] = "StreamError", e;
+}({}), ee = (e) => ({
 	logAction: (t, n, r) => {
 		e.error(n, { detail: r });
 	},
 	shouldLog: () => !0
-}), S = i.Realtime.EventEmitter, C = class extends S {
+}), te = s.Realtime.EventEmitter, k = class extends te {
 	constructor(e) {
-		super(x(e));
+		super(ee(e));
 	}
-}, w = /* @__PURE__ */ function(e) {
+}, A = /* @__PURE__ */ function(e) {
 	return e.Trace = "trace", e.Debug = "debug", e.Info = "info", e.Warn = "warn", e.Error = "error", e.Silent = "silent", e;
-}({}), T = (e, t, n) => {
+}({}), ne = (e, t, n) => {
 	let r = n ? `, context: ${JSON.stringify(n)}` : "", i = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${t.valueOf().toUpperCase()} ably-ai-transport: ${e}${r}`;
 	switch (t) {
-		case w.Trace:
-		case w.Debug:
+		case A.Trace:
+		case A.Debug:
 			console.log(i);
 			break;
-		case w.Info:
+		case A.Info:
 			console.info(i);
 			break;
-		case w.Warn:
+		case A.Warn:
 			console.warn(i);
 			break;
-		case w.Error:
+		case A.Error:
 			console.error(i);
 			break;
-		case w.Silent: break;
+		case A.Silent: break;
 	}
-}, E = (e) => new k(e.logHandler ?? T, e.logLevel), D = /* @__PURE__ */ function(e) {
+}, re = (e) => new N(e.logHandler ?? ne, e.logLevel), j = /* @__PURE__ */ function(e) {
 	return e[e.Trace = 0] = "Trace", e[e.Debug = 1] = "Debug", e[e.Info = 2] = "Info", e[e.Warn = 3] = "Warn", e[e.Error = 4] = "Error", e[e.Silent = 5] = "Silent", e;
-}(D || {}), O = new Map([
-	[w.Trace, D.Trace],
-	[w.Debug, D.Debug],
-	[w.Info, D.Info],
-	[w.Warn, D.Warn],
-	[w.Error, D.Error],
-	[w.Silent, D.Silent]
-]), k = class e {
+}(j || {}), M = new Map([
+	[A.Trace, j.Trace],
+	[A.Debug, j.Debug],
+	[A.Info, j.Info],
+	[A.Warn, j.Warn],
+	[A.Error, j.Error],
+	[A.Silent, j.Silent]
+]), N = class e {
 	constructor(e, t, n) {
 		this._handler = e, this._context = n;
-		let r = O.get(t);
-		if (r === void 0) throw new i.ErrorInfo(`unable to create logger; invalid log level: ${t}`, b.InvalidArgument, 400);
+		let r = M.get(t);
+		if (r === void 0) throw new s.ErrorInfo(`unable to create logger; invalid log level: ${t}`, O.InvalidArgument, 400);
 		this._levelNumber = r;
 	}
 	trace(e, t) {
-		this._write(e, w.Trace, D.Trace, t);
+		this._write(e, A.Trace, j.Trace, t);
 	}
 	debug(e, t) {
-		this._write(e, w.Debug, D.Debug, t);
+		this._write(e, A.Debug, j.Debug, t);
 	}
 	info(e, t) {
-		this._write(e, w.Info, D.Info, t);
+		this._write(e, A.Info, j.Info, t);
 	}
 	warn(e, t) {
-		this._write(e, w.Warn, D.Warn, t);
+		this._write(e, A.Warn, j.Warn, t);
 	}
 	error(e, t) {
-		this._write(e, w.Error, D.Error, t);
+		this._write(e, A.Error, j.Error, t);
 	}
 	withContext(t) {
-		let n = [...O.entries()].find(([, e]) => e === this._levelNumber)?.[0] ?? w.Error;
+		let n = [...M.entries()].find(([, e]) => e === this._levelNumber)?.[0] ?? A.Error;
 		return new e(this._handler, n, this._mergeContext(t));
 	}
 	_write(e, t, n, r) {
@@ -98,14 +78,70 @@ var a = (e) => {
 			...e
 		} : this._context : e ?? void 0;
 	}
-}, A = (e) => {
+}, P = (e) => {
 	let t = e.extras;
 	if (!t || typeof t != "object") return {};
 	let n = t.headers;
 	return !n || typeof n != "object" ? {} : n;
-}, j = class {
+}, F = (e) => {
+	let t = {
+		[_]: e.role,
+		[m]: e.turnId,
+		[h]: e.msgId
+	};
+	return e.turnClientId !== void 0 && (t[g] = e.turnClientId), e.parent && (t[C] = e.parent), e.forkOf && (t[w] = e.forkOf), e.amend && (t[v] = e.amend), t;
+}, I = class {
 	constructor(e, t) {
-		this._nodeIndex = /* @__PURE__ */ new Map(), this._codecKeyIndex = /* @__PURE__ */ new Map(), this._sortedList = [], this._parentIndex = /* @__PURE__ */ new Map(), this._selections = /* @__PURE__ */ new Map(), this._seqCounter = 0, this._getKey = e, this._logger = t;
+		this._turns = /* @__PURE__ */ new Map(), this._isTerminal = e, this._logger = t;
+	}
+	createStream(e) {
+		this._logger.trace("StreamRouter.createStream();", { turnId: e });
+		let t = {}, n = new ReadableStream({ start(e) {
+			t.controller = e;
+		} });
+		if (!t.controller) throw new s.ErrorInfo("unable to create stream; ReadableStream start() was not called synchronously", O.TransportSubscriptionError, 500);
+		return this._turns.set(e, {
+			controller: t.controller,
+			turnId: e
+		}), n;
+	}
+	closeStream(e) {
+		let t = this._turns.get(e);
+		if (!t) return !1;
+		this._logger.debug("StreamRouter.closeStream(); closing stream", { turnId: e });
+		try {
+			t.controller.close();
+		} catch {}
+		return this._turns.delete(e), !0;
+	}
+	errorStream(e, t) {
+		let n = this._turns.get(e);
+		if (!n) return !1;
+		this._logger.debug("StreamRouter.errorStream(); erroring stream", { turnId: e });
+		try {
+			n.controller.error(t);
+		} catch {}
+		return this._turns.delete(e), !0;
+	}
+	route(e, t) {
+		let n = this._turns.get(e);
+		if (!n) return !1;
+		try {
+			n.controller.enqueue(t);
+		} catch {
+			return this._turns.delete(e), !1;
+		}
+		return this._isTerminal(t) && this.closeStream(e), !0;
+	}
+	has(e) {
+		return this._turns.has(e);
+	}
+}, L = (e, t) => new I(e, t), R = class {
+	get structuralVersion() {
+		return this._structuralVersion;
+	}
+	constructor(e) {
+		this._nodeIndex = /* @__PURE__ */ new Map(), this._sortedList = [], this._parentIndex = /* @__PURE__ */ new Map(), this._turnClientIds = /* @__PURE__ */ new Map(), this._seqCounter = 0, this._structuralVersion = 0, this._logger = e, this._emitter = new k(e);
 	}
 	_compareNodes(e, t) {
 		let n = e.node.serial, r = t.node.serial;
@@ -164,7 +200,7 @@ var a = (e) => {
 		}
 		return !1;
 	}
-	_getGroupRoot(e) {
+	getGroupRoot(e) {
 		let t = this._nodeIndex.get(e);
 		if (!t) return e;
 		let n = t.node, r = new Set([n.msgId]);
@@ -175,75 +211,63 @@ var a = (e) => {
 		}
 		return n.msgId;
 	}
-	flatten() {
-		let e = [], t = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Map();
-		for (let r of this._sortedList) {
-			let i = r.node, { msgId: a, parentId: o } = i;
-			if (o !== void 0 && !t.has(o)) continue;
-			let s = this._getSiblingGroup(a);
-			if (s.length > 1) {
-				let e = this._getGroupRoot(a), t = n.get(e);
-				if (t === void 0) {
-					let r = this._selections.get(e) ?? s.length - 1, i = s[Math.max(0, Math.min(r, s.length - 1))];
-					if (!i) break;
-					t = i.msgId, n.set(e, t);
+	flattenNodes(e) {
+		this._logger.trace("DefaultTree.flattenNodes();");
+		let t = [], n = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Map();
+		for (let i of this._sortedList) {
+			let a = i.node, { msgId: o, parentId: s } = a;
+			if (s !== void 0 && !n.has(s)) continue;
+			let c = this._getSiblingGroup(o);
+			if (c.length > 1) {
+				let t = this.getGroupRoot(o), n = r.get(t);
+				if (n === void 0) {
+					let i = e.get(t);
+					if (i && c.some((e) => e.msgId === i)) n = i;
+					else {
+						let e = c.at(-1);
+						if (!e) break;
+						n = e.msgId;
+					}
+					r.set(t, n);
 				}
-				if (a !== t) continue;
+				if (o !== n) continue;
 			}
-			t.add(a), e.push(i.message);
+			n.add(o), t.push(a);
 		}
-		return e;
+		return t;
 	}
 	getSiblings(e) {
-		return this._getSiblingGroup(e).map((e) => e.message);
+		return this._logger.trace("DefaultTree.getSiblings();", { msgId: e }), this._getSiblingGroup(e).map((e) => e.message);
+	}
+	getSiblingNodes(e) {
+		return this._getSiblingGroup(e);
 	}
 	hasSiblings(e) {
 		return this._getSiblingGroup(e).length > 1;
 	}
-	getSelectedIndex(e) {
-		let t = this._getSiblingGroup(e);
-		if (t.length <= 1) return 0;
-		let n = this._getGroupRoot(e), r = this._selections.get(n);
-		return r === void 0 ? t.length - 1 : Math.max(0, Math.min(r, t.length - 1));
-	}
-	select(e, t) {
-		this._logger.debug("ConversationTree.select();", {
-			msgId: e,
-			index: t
-		});
-		let n = this._getSiblingGroup(e);
-		if (n.length <= 1) return;
-		let r = this._getGroupRoot(e);
-		this._selections.set(r, Math.max(0, Math.min(t, n.length - 1)));
-	}
 	getNode(e) {
-		return this._nodeIndex.get(e)?.node;
-	}
-	getNodeByKey(e) {
-		let t = this._codecKeyIndex.get(e);
-		if (t) return this._nodeIndex.get(t)?.node;
+		return this._logger.trace("DefaultTree.getNode();", { msgId: e }), this._nodeIndex.get(e)?.node;
 	}
 	getHeaders(e) {
-		return this._nodeIndex.get(e)?.node.headers;
+		return this._logger.trace("DefaultTree.getHeaders();", { msgId: e }), this._nodeIndex.get(e)?.node.headers;
 	}
 	upsert(e, t, n, r) {
-		let i = n["x-ably-parent"] ?? void 0, a = n["x-ably-fork-of"] ?? void 0;
-		this._codecKeyIndex.set(this._getKey(t), e);
-		let o = this._nodeIndex.get(e);
+		let i = n["x-ably-parent"] ?? void 0, a = n["x-ably-fork-of"] ?? void 0, o = this._nodeIndex.get(e);
 		if (o) {
-			o.node.message = t, Object.keys(n).length > 0 && (o.node.headers = { ...n }), r && !o.node.serial && (this._logger.debug("ConversationTree.upsert(); promoting serial", {
+			o.node.message = t, Object.keys(n).length > 0 && (o.node.headers = { ...n }), r && !o.node.serial && (this._logger.debug("Tree.upsert(); promoting serial", {
 				msgId: e,
 				serial: r
-			}), o.node.serial = r, this._removeSorted(o), this._insertSorted(o));
+			}), o.node.serial = r, this._removeSorted(o), this._insertSorted(o), this._structuralVersion++), this._emitter.emit("update");
 			return;
 		}
-		this._logger.trace("ConversationTree.upsert(); inserting new node", {
+		this._logger.trace("Tree.upsert(); inserting new node", {
 			msgId: e,
 			parentId: i,
 			forkOf: a
 		});
 		let s = {
 			node: {
+				kind: "message",
 				message: t,
 				msgId: e,
 				parentId: i,
@@ -253,19 +277,60 @@ var a = (e) => {
 			},
 			insertSeq: this._seqCounter++
 		};
-		this._nodeIndex.set(e, s), this._addToParentIndex(i, e), this._insertSorted(s);
+		this._nodeIndex.set(e, s), this._addToParentIndex(i, e), this._insertSorted(s), this._structuralVersion++, this._emitter.emit("update");
 	}
 	delete(e) {
 		let t = this._nodeIndex.get(e);
 		if (!t) return;
-		this._logger.debug("ConversationTree.delete();", { msgId: e });
-		let { node: n } = t, r = this._getKey(n.message);
-		this._codecKeyIndex.get(r) === e && this._codecKeyIndex.delete(r), this._removeFromParentIndex(n.parentId, e), this._removeSorted(t), this._nodeIndex.delete(e), this._selections.delete(e);
+		this._logger.debug("Tree.delete();", { msgId: e });
+		let { node: n } = t;
+		this._removeFromParentIndex(n.parentId, e), this._removeSorted(t), this._nodeIndex.delete(e), this._structuralVersion++, this._emitter.emit("update");
+	}
+	getActiveTurnIds() {
+		this._logger.trace("DefaultTree.getActiveTurnIds();");
+		let e = /* @__PURE__ */ new Map();
+		for (let [t, n] of this._turnClientIds) {
+			let r = e.get(n);
+			r || (r = /* @__PURE__ */ new Set(), e.set(n, r)), r.add(t);
+		}
+		return e;
+	}
+	on(e, t) {
+		let n = t;
+		return this._emitter.on(e, n), () => {
+			this._emitter.off(e, n);
+		};
+	}
+	emitAblyMessage(e) {
+		this._logger.trace("DefaultTree.emitAblyMessage();"), this._emitter.emit("ably-message", e);
+	}
+	emitTurn(e) {
+		this._logger.trace("DefaultTree.emitTurn();", { turnId: e.turnId }), this._emitter.emit("turn", e);
+	}
+	trackTurn(e, t) {
+		this._logger.trace("DefaultTree.trackTurn();", {
+			turnId: e,
+			clientId: t
+		}), this._turnClientIds.set(e, t);
+	}
+	untrackTurn(e) {
+		this._logger.trace("DefaultTree.untrackTurn();", { turnId: e }), this._turnClientIds.delete(e);
 	}
-}, M = (e, t) => new j(e, t), N = (e) => {
-	let t = [...e.rawMessages].toReversed(), n = e.codec.createDecoder(), r = /* @__PURE__ */ new Map(), i = e.codec.createAccumulator(), a = 0, c = /* @__PURE__ */ new Map(), l = /* @__PURE__ */ new Map();
+}, z = (e) => new R(e), B = (e) => {
+	let t = [...e.rawMessages].toReversed(), n = e.codec.createDecoder(), r = /* @__PURE__ */ new Map(), i = e.codec.createAccumulator(), a = 0, o = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map(), c = [], l = [];
 	for (let u of t) {
-		let t = n.decode(u), d = A(u), f = d[o], p = d[s], m = u.serial;
+		let t = n.decode(u), d = P(u), f = d[m], p = d[h], g = u.serial, _ = d[v];
+		if (_) {
+			for (let e of r.values()) if (e.msgHeaders.has(_)) {
+				let n = [...e.msgHeaders.keys()].indexOf(_), r = n === -1 ? void 0 : e.accumulator.messages[n];
+				r && e.accumulator.initMessage(_, r), e.accumulator.processOutputs(t), l.push({
+					accumulator: e.accumulator,
+					messageId: _
+				});
+				break;
+			}
+			continue;
+		}
 		if (f) {
 			let n = r.get(f);
 			if (n || (n = {
@@ -275,202 +340,517 @@ var a = (e) => {
 				msgSerials: /* @__PURE__ */ new Map()
 			}, r.set(f, n)), p) {
 				let e = n.msgHeaders.get(p);
-				e ? Object.keys(d).length > 0 && Object.assign(e, d) : (n.msgHeaders.set(p, { ...d }), m && n.msgSerials.set(p, m));
+				e ? Object.keys(d).length > 0 && Object.assign(e, d) : (n.msgHeaders.set(p, { ...d }), g && n.msgSerials.set(p, g));
 			}
 			n.accumulator.processOutputs(t);
-		} else i.processOutputs(t);
-		for (let n of t) if (n.kind === "message") {
-			let t = e.getMessageKey(n.message), r = c.get(t);
-			r ? Object.keys(d).length > 0 && Object.assign(r, d) : (c.set(t, { ...d }), m && l.set(t, m));
+		} else {
+			i.processOutputs(t);
+			for (let e of t) if (e.kind === "message" && p) {
+				c.push(p);
+				let e = o.get(p);
+				e ? Object.keys(d).length > 0 && Object.assign(e, d) : (o.set(p, { ...d }), g && s.set(p, g));
+			}
 		}
 	}
+	for (let { accumulator: e, messageId: t } of l) e.completeMessage(t);
 	let u = [];
-	for (let t of i.completedMessages) {
-		let n = e.getMessageKey(t);
+	for (let [e, t] of i.completedMessages.entries()) {
+		let n = c[e];
 		u.push({
 			message: t,
-			headers: c.get(n) ?? {},
-			serial: l.get(n) ?? ""
+			headers: n ? o.get(n) ?? {} : {},
+			serial: n ? s.get(n) ?? "" : ""
 		});
 	}
 	let d = [...r.values()].toSorted((e, t) => e.firstSeen - t.firstSeen);
-	for (let t of d) {
-		let n = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map();
-		for (let a of t.accumulator.completedMessages) {
-			let t = e.getMessageKey(a), o = c.get(t);
-			if (o) {
-				r.set(t, o);
-				let e = l.get(t);
-				e && i.set(t, e);
-				let a = o[s];
-				a && n.add(a);
-			}
-		}
-		let a = [...t.msgHeaders.entries()].filter(([e]) => !n.has(e)), o = 0;
-		for (let n of t.accumulator.completedMessages) {
-			let s = e.getMessageKey(n), c = a[o];
-			if (!r.has(s) && c) {
-				let [e, n] = c;
-				r.set(s, n);
-				let a = t.msgSerials.get(e);
-				a && i.set(s, a), o++;
-			}
-		}
-		for (let n of t.accumulator.completedMessages) {
-			let t = e.getMessageKey(n);
-			u.push({
-				message: n,
-				headers: r.get(t) ?? {},
-				serial: i.get(t) ?? ""
+	for (let e of d) {
+		let t = [...e.msgHeaders.entries()], n = 0;
+		for (let r of e.accumulator.completedMessages) {
+			let i = t[n];
+			if (i) {
+				let [t, a] = i;
+				u.push({
+					message: r,
+					headers: a,
+					serial: e.msgSerials.get(t) ?? ""
+				}), n++;
+			} else u.push({
+				message: r,
+				headers: {},
+				serial: ""
 			});
 		}
 	}
 	return u.toReversed();
-}, P = async (e, t, n) => {
-	e.rawMessages.push(...t.items), e.lastAblyPage = t;
-	let r = N(e).length;
-	for (; r < e.returnedCount + n && t.hasNext();) {
+}, ie = (e) => {
+	if (e.cachedDecode && e.cachedAtRawLength === e.rawMessages.length) return e.cachedDecode;
+	let t = B(e);
+	return e.cachedDecode = t, e.cachedAtRawLength = e.rawMessages.length, t;
+}, V = (e, t) => {
+	for (let n of t) {
+		let t = P(n), r = t[h];
+		if (!r || t["x-ably-amend"]) continue;
+		let i = n.action, a = i === "message.create" && "x-ably-discrete" in t, o = t["x-ably-stream"] === "true" && (i === "message.create" || i === "message.update" || i === "message.append"), s = t[p], c = s === "finished" || s === "aborted";
+		(a || o) && e.startedMsgIds.add(r), (a || c) && e.terminatedMsgIds.add(r), e.startedMsgIds.has(r) && e.terminatedMsgIds.has(r) && e.completedMsgIds.add(r);
+	}
+}, H = async (e, t, n) => {
+	e.rawMessages.push(...t.items), e.lastAblyPage = t, V(e, t.items);
+	let r = e.returnedCount + n;
+	for (; e.completedMsgIds.size < r && t.hasNext();) {
 		e.logger.debug("decodeHistory.fetchUntilLimit(); fetching next page", {
 			collected: e.rawMessages.length,
-			decoded: r
+			completed: e.completedMsgIds.size
 		});
 		let n = await t.next();
 		if (!n) break;
-		t = n, e.rawMessages.push(...n.items), e.lastAblyPage = n, r = N(e).length;
+		t = n, e.rawMessages.push(...n.items), e.lastAblyPage = n, V(e, n.items);
 	}
-}, F = (e, t) => {
-	let n = N(e), r = n.slice(e.returnedCount, e.returnedCount + t), i = [...r].toReversed();
+}, U = (e, t) => {
+	let n = ie(e), r = n.slice(e.returnedCount, e.returnedCount + t), i = [...r].toReversed();
 	e.returnedCount += r.length;
 	let a = n.length > e.returnedCount, o = e.lastAblyPage?.hasNext() ?? !1, s = e.rawMessages.length - e.returnedRawCount > 0 ? e.rawMessages.slice(e.returnedRawCount).toReversed() : [];
 	return e.returnedRawCount = e.rawMessages.length, {
-		items: i.map((e) => e.message),
-		itemHeaders: i.map((e) => e.headers),
-		itemSerials: i.map((e) => e.serial),
+		items: i.map((e) => ({
+			message: e.message,
+			headers: e.headers,
+			serial: e.serial
+		})),
 		rawMessages: s,
 		hasNext: () => a || o,
 		next: async () => {
-			if (a) return F(e, t);
+			if (a) return U(e, t);
 			if (!o || !e.lastAblyPage) return;
 			let n = await e.lastAblyPage.next();
-			if (n) return await P(e, n, t), F(e, t);
+			if (n) return await H(e, n, t), U(e, t);
 		}
 	};
-}, I = async (e, t, n, r) => {
+}, ae = async (e, t, n, r) => {
 	let i = n?.limit ?? 100, a = {
 		codec: t,
 		rawMessages: [],
 		returnedCount: 0,
 		returnedRawCount: 0,
 		lastAblyPage: void 0,
-		getMessageKey: t.getMessageKey.bind(t),
+		cachedDecode: void 0,
+		cachedAtRawLength: 0,
+		startedMsgIds: /* @__PURE__ */ new Set(),
+		terminatedMsgIds: /* @__PURE__ */ new Set(),
+		completedMsgIds: /* @__PURE__ */ new Set(),
 		logger: r
 	};
 	r.trace("decodeHistory();", { limit: i });
 	let o = i * 10;
-	return await e.attach(), await P(a, await e.history({
+	return await e.attach(), await H(a, await e.history({
 		untilAttach: !0,
 		limit: o
-	}), i), F(a, i);
-}, L = (e) => {
-	let t = {
-		[l]: e.role,
-		[o]: e.turnId,
-		[s]: e.msgId
-	};
-	return e.turnClientId !== void 0 && (t[c] = e.turnClientId), e.parent && (t[m] = e.parent), e.forkOf && (t[h] = e.forkOf), t;
-}, R = class {
-	constructor(e, t) {
-		this._turns = /* @__PURE__ */ new Map(), this._isTerminal = e, this._logger = t;
+	}), i), U(a, i);
+}, oe = class {
+	constructor(e) {
+		this._branchSelections = /* @__PURE__ */ new Map(), this._withheldMsgIds = /* @__PURE__ */ new Set(), this._lastVisibleIds = [], this._lastVisibleMessages = [], this._lastVisibleTurnIds = /* @__PURE__ */ new Set(), this._hasMoreHistory = !1, this._withheldBuffer = [], this._unsubs = [], this._cachedNodes = [], this._lastStructuralVersion = -1, this._loadingOlder = !1, this._processingHistory = !1, this._closed = !1, this._tree = e.tree, this._channel = e.channel, this._codec = e.codec, this._sendDelegate = e.sendDelegate, this._onClose = e.onClose, this._logger = e.logger.withContext({ component: "View" }), this._logger.trace("DefaultView();"), this._emitter = new k(this._logger), this._cachedNodes = this._computeFlatNodes(), this._lastStructuralVersion = this._tree.structuralVersion, this._updateVisibleSnapshot(this._cachedNodes), this._unsubs.push(this._tree.on("update", () => {
+			this._onTreeUpdate();
+		}), this._tree.on("ably-message", (e) => {
+			this._onTreeAblyMessage(e);
+		}), this._tree.on("turn", (e) => {
+			this._onTreeTurn(e);
+		}));
 	}
-	createStream(e) {
-		this._logger.trace("StreamRouter.createStream();", { turnId: e });
-		let t = {}, n = new ReadableStream({ start(e) {
-			t.controller = e;
-		} });
-		if (!t.controller) throw new i.ErrorInfo("unable to create stream; ReadableStream start() was not called synchronously", b.TransportSubscriptionError, 500);
-		return this._turns.set(e, {
-			controller: t.controller,
-			turnId: e
-		}), n;
+	getMessages() {
+		return this.flattenNodes().map((e) => e.message);
 	}
-	closeStream(e) {
-		let t = this._turns.get(e);
-		if (!t) return !1;
-		this._logger.debug("StreamRouter.closeStream(); closing stream", { turnId: e });
-		try {
-			t.controller.close();
-		} catch {}
-		return this._turns.delete(e), !0;
+	flattenNodes() {
+		return this._cachedNodes;
 	}
-	route(e, t) {
-		let n = this._turns.get(e);
-		if (!n) return !1;
+	_computeFlatNodes() {
+		let e = this._tree.flattenNodes(this._resolveSelections());
+		return this._withheldMsgIds.size === 0 ? e : e.filter((e) => !this._withheldMsgIds.has(e.msgId));
+	}
+	hasOlder() {
+		return this._withheldBuffer.length > 0 || this._hasMoreHistory;
+	}
+	async loadOlder(e = 100) {
+		if (!(this._closed || this._loadingOlder)) {
+			this._loadingOlder = !0, this._logger.trace("DefaultView.loadOlder();", { limit: e });
+			try {
+				if (this._withheldBuffer.length > 0) {
+					let t = this._withheldBuffer.splice(-e, e);
+					this._releaseWithheld(t);
+					return;
+				}
+				if (!this._hasMoreHistory && !this._lastHistoryPage) {
+					await this._loadFirstPage(e);
+					return;
+				}
+				if (!this._hasMoreHistory) return;
+				if (!this._lastHistoryPage?.hasNext()) {
+					this._hasMoreHistory = !1;
+					return;
+				}
+				let t = await this._lastHistoryPage.next();
+				if (this._closed || !t) {
+					t || (this._hasMoreHistory = !1);
+					return;
+				}
+				await this._loadAndReveal(t, e);
+			} catch (e) {
+				throw this._logger.error("DefaultView.loadOlder(); failed", { error: e }), e;
+			} finally {
+				this._loadingOlder = !1;
+			}
+		}
+	}
+	select(e, t) {
+		this._logger.trace("DefaultView.select();", {
+			msgId: e,
+			index: t
+		});
+		let n = this._tree.getSiblingNodes(e);
+		if (n.length <= 1) return;
+		let r = this._tree.getGroupRoot(e), i = Math.max(0, Math.min(t, n.length - 1)), a = n[i];
+		a && (this._branchSelections.set(r, {
+			kind: "user",
+			selectedId: a.msgId
+		}), this._logger.debug("DefaultView.select();", {
+			msgId: e,
+			index: i,
+			selectedId: a.msgId
+		}), this._cachedNodes = this._computeFlatNodes(), this._updateVisibleSnapshot(this._cachedNodes), this._emitter.emit("update"));
+	}
+	getSelectedIndex(e) {
+		this._logger.trace("DefaultView.getSelectedIndex();", { msgId: e });
+		let t = this._tree.getSiblingNodes(e);
+		if (t.length <= 1) return 0;
+		let n = this._tree.getGroupRoot(e), r = this._branchSelections.get(n);
+		if (!r || r.kind === "pending") return t.length - 1;
+		let i = t.findIndex((e) => e.msgId === r.selectedId);
+		return i === -1 ? t.length - 1 : i;
+	}
+	getSiblings(e) {
+		return this._tree.getSiblings(e);
+	}
+	hasSiblings(e) {
+		return this._tree.hasSiblings(e);
+	}
+	getNode(e) {
+		return this._tree.getNode(e);
+	}
+	async send(e, t) {
+		if (this._logger.trace("DefaultView.send();"), this._closed) throw new s.ErrorInfo("unable to send; view is closed", O.InvalidArgument, 400);
+		let n = this.flattenNodes(), r = await this._sendDelegate(e, t, n);
+		if (t?.forkOf) {
+			let e = this._tree.getGroupRoot(t.forkOf);
+			if (r.optimisticMsgIds.length > 0) {
+				let t = r.optimisticMsgIds.at(-1);
+				t && (this._branchSelections.set(e, {
+					kind: "auto",
+					selectedId: t
+				}), this._cachedNodes = this._computeFlatNodes(), this._updateVisibleSnapshot(this._cachedNodes), this._emitter.emit("update"));
+			} else {
+				this._branchSelections.set(e, {
+					kind: "pending",
+					turnId: r.turnId
+				}), this._logger.debug("DefaultView.send(); deferring fork auto-selection", {
+					forkOf: t.forkOf,
+					groupRoot: e,
+					turnId: r.turnId
+				});
+				let n = this._tree.on("turn", (t) => {
+					if (t.type !== "x-ably-turn-end" || t.turnId !== r.turnId) return;
+					let i = this._branchSelections.get(e);
+					i?.kind === "pending" && i.turnId === r.turnId && this._branchSelections.delete(e), n();
+					let a = this._unsubs.indexOf(n);
+					a !== -1 && this._unsubs.splice(a, 1);
+				});
+				this._unsubs.push(n);
+			}
+		}
+		return r;
+	}
+	async regenerate(e, t) {
+		this._logger.trace("DefaultView.regenerate();", { messageId: e });
+		let n = this._tree.getNode(e);
+		if (!n) throw new s.ErrorInfo(`unable to regenerate; message not found in tree: ${e}`, O.InvalidArgument, 400);
+		let r = n.parentId;
+		return this.send([], {
+			...t,
+			body: {
+				history: this._getHistoryBefore(e),
+				...t?.body
+			},
+			forkOf: e,
+			parent: r
+		});
+	}
+	async edit(e, t, n) {
+		this._logger.trace("DefaultView.edit();", { messageId: e });
+		let r = this._tree.getNode(e);
+		if (!r) throw new s.ErrorInfo(`unable to edit; message not found in tree: ${e}`, O.InvalidArgument, 400);
+		let i = r.parentId;
+		return this.send(t, {
+			...n,
+			body: {
+				history: this._getHistoryBefore(e),
+				...n?.body
+			},
+			forkOf: e,
+			parent: i
+		});
+	}
+	async update(e, t, n) {
+		if (this._closed) throw new s.ErrorInfo("unable to update; view is closed", O.InvalidArgument, 400);
+		this._logger.trace("DefaultView.update();", {
+			msgId: e,
+			eventCount: t.length
+		});
+		let r = [{
+			kind: "event",
+			msgId: e,
+			events: t
+		}];
+		return this._sendDelegate([], n, this.flattenNodes(), r);
+	}
+	_getHistoryBefore(e) {
+		this._logger.trace("DefaultView._getHistoryBefore();", { messageId: e });
+		let t = this.flattenNodes(), n = t.findIndex((t) => t.msgId === e);
+		return n === -1 ? (this._logger.warn("DefaultView._getHistoryBefore(); target not in visible nodes, returning full list", { messageId: e }), t) : t.slice(0, n);
+	}
+	getActiveTurnIds() {
+		this._logger.trace("DefaultView.getActiveTurnIds();");
+		let e = this._tree.getActiveTurnIds();
+		if (this._withheldMsgIds.size === 0) return e;
+		let t = /* @__PURE__ */ new Map();
+		for (let [n, r] of e) {
+			let e = /* @__PURE__ */ new Set();
+			for (let t of r) this._lastVisibleTurnIds.has(t) && e.add(t);
+			e.size > 0 && t.set(n, e);
+		}
+		return t;
+	}
+	on(e, t) {
+		let n = t;
+		return this._emitter.on(e, n), () => {
+			this._emitter.off(e, n);
+		};
+	}
+	close() {
+		this._logger.info("DefaultView.close();"), this._closed = !0, this._loadingOlder = !1;
+		for (let e of this._unsubs) e();
+		this._unsubs.length = 0, this._emitter.off(), this._branchSelections.clear(), this._withheldMsgIds.clear(), this._withheldBuffer.length = 0, this._onClose?.();
+	}
+	async _loadFirstPage(e) {
+		let t = new Set(this._tree.flattenNodes(this._resolveSelections()).map((e) => e.msgId)), n = await ae(this._channel, this._codec, { limit: e }, this._logger);
+		if (this._closed) return;
+		let { newVisible: r, lastPage: i } = await this._loadUntilVisible(n, e, t);
+		if (this._closed) return;
+		this._lastHistoryPage = i, this._hasMoreHistory = i.hasNext();
+		let a = r.slice(-e), o = r.slice(0, -e);
+		for (let e of o) this._withheldMsgIds.add(e.msgId);
+		this._withheldBuffer.push(...o), this._releaseWithheld(a);
+	}
+	async _loadAndReveal(e, t) {
+		let n = new Set(this._tree.flattenNodes(this._resolveSelections()).map((e) => e.msgId)), { newVisible: r, lastPage: i } = await this._loadUntilVisible(e, t, n);
+		if (this._closed) return;
+		this._lastHistoryPage = i, this._hasMoreHistory = i.hasNext();
+		let a = r.slice(-t), o = r.slice(0, -t);
+		for (let e of o) this._withheldMsgIds.add(e.msgId);
+		this._withheldBuffer.push(...o), this._releaseWithheld(a);
+	}
+	_processHistoryPage(e) {
+		this._processingHistory = !0;
 		try {
-			n.controller.enqueue(t);
-		} catch {
-			return this._turns.delete(e), !1;
+			for (let t of e.items) {
+				let e = t.headers[h];
+				e && this._tree.upsert(e, t.message, t.headers, t.serial);
+			}
+			for (let t of e.rawMessages) this._tree.emitAblyMessage(t);
+		} finally {
+			this._processingHistory = !1;
 		}
-		return this._isTerminal(t) && this.closeStream(e), !0;
 	}
-	has(e) {
-		return this._turns.has(e);
+	async _loadUntilVisible(e, t, n) {
+		this._processHistoryPage(e);
+		let r = e, i = () => {
+			let e = 0;
+			for (let t of this._tree.flattenNodes(this._resolveSelections())) n.has(t.msgId) || e++;
+			return e;
+		};
+		for (; i() < t && r.hasNext();) {
+			let e = await r.next();
+			if (!e || this._closed) break;
+			this._processHistoryPage(e), r = e;
+		}
+		return {
+			newVisible: this._tree.flattenNodes(this._resolveSelections()).filter((e) => !n.has(e.msgId)),
+			lastPage: r
+		};
+	}
+	_releaseWithheld(e) {
+		for (let t of e) this._withheldMsgIds.delete(t.msgId);
+		e.length > 0 && (this._cachedNodes = this._computeFlatNodes(), this._updateVisibleSnapshot(this._cachedNodes), this._emitter.emit("update"));
+	}
+	_updateVisibleSnapshot(e) {
+		let t = e ?? this.flattenNodes();
+		this._lastVisibleIds = t.map((e) => e.msgId), this._lastVisibleMessages = t.map((e) => e.message), this._lastVisibleTurnIds = /* @__PURE__ */ new Set();
+		for (let e of t) {
+			let t = e.headers[m];
+			t && this._lastVisibleTurnIds.add(t);
+		}
+	}
+	_onTreeUpdate() {
+		if (this._processingHistory) return;
+		let e = this._tree.structuralVersion;
+		if (e === this._lastStructuralVersion) {
+			this._cachedNodes.some((e, t) => e.message !== this._lastVisibleMessages[t]) && (this._lastVisibleMessages = this._cachedNodes.map((e) => e.message), this._cachedNodes = [...this._cachedNodes], this._emitter.emit("update"));
+			return;
+		}
+		this._lastStructuralVersion = e, this._pinBranchSelections(), this._resolvePendingSelections();
+		let t = this._computeFlatNodes(), n = t.map((e) => e.msgId), r = t.map((e) => e.message);
+		this._visibleChanged(n, r) && (this._cachedNodes = t, this._updateVisibleSnapshot(t), this._emitter.emit("update"));
+	}
+	_resolveSelections() {
+		let e = /* @__PURE__ */ new Map();
+		for (let [t, n] of this._branchSelections) n.kind !== "pending" && e.set(t, n.selectedId);
+		return e;
+	}
+	_pinBranchSelections() {
+		for (let e of this._lastVisibleIds) {
+			if (!this._tree.hasSiblings(e)) continue;
+			let t = this._tree.getGroupRoot(e), n = this._branchSelections.get(t);
+			if (n?.kind === "pending") {
+				let r = this._tree.getSiblingNodes(e).at(-1);
+				r && r.msgId !== e && r.headers["x-ably-turn-id"] === n.turnId && (this._logger.debug("DefaultView._pinBranchSelections(); auto-selecting pending fork", {
+					msgId: e,
+					newestId: r.msgId,
+					turnId: n.turnId
+				}), this._branchSelections.set(t, {
+					kind: "auto",
+					selectedId: r.msgId
+				}));
+				continue;
+			}
+			n || this._branchSelections.set(t, {
+				kind: "pinned",
+				selectedId: e
+			});
+		}
+	}
+	_resolvePendingSelections() {
+		for (let [e, t] of this._branchSelections) {
+			if (t.kind !== "pending") continue;
+			let n = this._tree.getSiblingNodes(e);
+			if (n.length <= 1) continue;
+			let r = n.at(-1);
+			!r || r.msgId === e || r.headers["x-ably-turn-id"] === t.turnId && (this._logger.debug("DefaultView._resolvePendingSelections(); resolving off-branch pending", {
+				groupRoot: e,
+				newestId: r.msgId,
+				turnId: t.turnId
+			}), this._branchSelections.set(e, {
+				kind: "auto",
+				selectedId: r.msgId
+			}));
+		}
+	}
+	_onTreeAblyMessage(e) {
+		let t = P(e)[h];
+		if (!t) {
+			this._emitter.emit("ably-message", e);
+			return;
+		}
+		this._lastVisibleIds.includes(t) && this._emitter.emit("ably-message", e);
+	}
+	_onTreeTurn(e) {
+		if (this._lastVisibleTurnIds.has(e.turnId)) {
+			this._emitter.emit("turn", e);
+			return;
+		}
+		e.type === "x-ably-turn-start" && this._isTurnStartVisible(e) && (this._lastVisibleTurnIds.add(e.turnId), this._emitter.emit("turn", e));
+	}
+	_isTurnStartVisible(e) {
+		let { parent: t } = e;
+		return t === void 0 ? !0 : this._lastVisibleIds.includes(t);
 	}
-}, z = (e, t) => new R(e, t), B = () => {}, V = class {
+	_visibleChanged(e, t) {
+		if (e.length !== this._lastVisibleIds.length) return !0;
+		for (let [t, n] of e.entries()) if (n !== this._lastVisibleIds[t]) return !0;
+		for (let [e, n] of t.entries()) if (n !== this._lastVisibleMessages[e]) return !0;
+		return !1;
+	}
+}, W = (e) => new oe(e), se = () => {}, G = /* @__PURE__ */ function(e) {
+	return e.READY = "ready", e.CLOSED = "closed", e;
+}(G || {}), ce = class {
 	constructor(e) {
-		if (this._ownMsgIds = /* @__PURE__ */ new Set(), this._ownTurnIds = /* @__PURE__ */ new Set(), this._turnClientIds = /* @__PURE__ */ new Map(), this._turnMsgIds = /* @__PURE__ */ new Map(), this._turnObservers = /* @__PURE__ */ new Map(), this._ablyMessages = [], this._withheldKeys = /* @__PURE__ */ new Set(), this._closed = !1, this._channel = e.channel, this._codec = e.codec, this._clientId = e.clientId, this._api = e.api ?? "/api/chat", this._credentials = e.credentials, this._headersFn = typeof e.headers == "function" ? e.headers : e.headers ? () => e.headers : void 0, this._bodyFn = typeof e.body == "function" ? e.body : e.body ? () => e.body : void 0, this._fetchFn = e.fetch ?? globalThis.fetch.bind(globalThis), this._logger = (e.logger ?? E({ logLevel: w.Silent })).withContext({ component: "ClientTransport" }), this._emitter = new C(this._logger), this._tree = M(this._codec.getMessageKey.bind(this._codec), this._logger), this._router = z(this._codec.isTerminal.bind(this._codec), this._logger), this._decoder = this._codec.createDecoder(), e.messages) {
+		if (this._ownMsgIds = /* @__PURE__ */ new Set(), this._ownTurnIds = /* @__PURE__ */ new Set(), this._turnMsgIds = /* @__PURE__ */ new Map(), this._turnObservers = /* @__PURE__ */ new Map(), this._closeResolvers = [], this._views = /* @__PURE__ */ new Set(), this._state = G.READY, this._pendingLocalEvents = [], this._channel = e.channel, this._codec = e.codec, this._clientId = e.clientId, this._api = e.api, this._credentials = e.credentials, this._headersFn = typeof e.headers == "function" ? e.headers : e.headers ? () => e.headers : void 0, this._bodyFn = typeof e.body == "function" ? e.body : e.body ? () => e.body : void 0, this._fetchFn = e.fetch ?? globalThis.fetch.bind(globalThis), this._logger = (e.logger ?? re({ logLevel: A.Silent })).withContext({ component: "ClientTransport" }), this._emitter = new k(this._logger), this._hasAttachedOnce = this._channel.state === "attached", this._tree = z(this._logger), this._view = W({
+			tree: this._tree,
+			channel: this._channel,
+			codec: this._codec,
+			sendDelegate: this._internalSend.bind(this),
+			logger: this._logger,
+			onClose: () => this._views.delete(this._view)
+		}), this._router = L(this._codec.isTerminal.bind(this._codec), this._logger), this._decoder = this._codec.createDecoder(), this._views.add(this._view), this.tree = this._tree, this.view = this._view, e.messages) {
 			let t;
 			for (let n of e.messages) {
-				let e = this._codec.getMessageKey(n), r = {};
-				t && (r[m] = t), this._tree.upsert(e, n, r), t = e;
+				let e = crypto.randomUUID(), r = { [h]: e };
+				t && (r[C] = t), this._tree.upsert(e, n, r), t = e;
 			}
-			this._emitter.emit("message");
 		}
 		this._onMessage = (e) => {
 			this._handleMessage(e);
-		}, this._attachPromise = this._channel.subscribe(this._onMessage);
+		}, this._attachPromise = this._channel.subscribe(this._onMessage), this._onChannelStateChange = (e) => {
+			this._handleChannelStateChange(e);
+		}, this._channel.on(this._onChannelStateChange);
 	}
 	_handleMessage(e) {
-		if (!this._closed) {
-			this._ablyMessages.push(e), this._emitter.emit("ably-message");
-			try {
-				if (e.name === "x-ably-turn-start") {
-					let t = A(e), n = t[o], r = t["x-ably-turn-client-id"] ?? "";
-					n && (this._turnClientIds.set(n, r), this._emitter.emit("turn", {
-						type: _,
+		if (this._state !== G.CLOSED) try {
+			if (e.name === "x-ably-turn-start") {
+				let t = P(e), n = t[m], r = t["x-ably-turn-client-id"] ?? "";
+				if (n) {
+					this._tree.trackTurn(n, r);
+					let e = t[C], i = t[w];
+					this._tree.emitTurn({
+						type: E,
 						turnId: n,
-						clientId: r
-					}));
-					return;
+						clientId: r,
+						...e !== void 0 && { parent: e },
+						...i !== void 0 && { forkOf: i }
+					});
 				}
-				if (e.name === "x-ably-turn-end") {
-					let t = A(e), n = t[o], r = t["x-ably-turn-client-id"] ?? "", i = t["x-ably-turn-reason"] ?? "complete";
-					if (n) {
-						this._router.closeStream(n), this._turnObservers.delete(n), this._turnClientIds.delete(n);
-						let e = this._turnMsgIds.get(n);
-						if (e) {
-							for (let t of e) this._ownMsgIds.delete(t);
-							this._turnMsgIds.delete(n);
-						}
-						this._ownTurnIds.delete(n), this._emitter.emit("turn", {
-							type: v,
-							turnId: n,
-							clientId: r,
-							reason: i
-						});
+				this._tree.emitAblyMessage(e);
+				return;
+			}
+			if (e.name === "x-ably-turn-end") {
+				let t = P(e), n = t[m], r = t["x-ably-turn-client-id"] ?? "", i = t["x-ably-turn-reason"] ?? "complete";
+				if (n) {
+					this._router.closeStream(n), this._turnObservers.delete(n), this._tree.untrackTurn(n);
+					let e = this._turnMsgIds.get(n);
+					if (e) {
+						for (let t of e) this._ownMsgIds.delete(t);
+						this._turnMsgIds.delete(n);
 					}
-					return;
+					this._ownTurnIds.delete(n), this._tree.emitTurn({
+						type: D,
+						turnId: n,
+						clientId: r,
+						reason: i
+					});
 				}
-				let t = this._decoder.decode(e), n = A(e), r = e.serial, i = n[o];
-				i && this._updateTurnObserverHeaders(i, n, r);
-				for (let i of t) i.kind === "message" ? this._handleMessageOutput(i.message, n, r, e.action) : this._handleEventOutput(i, n);
-			} catch (e) {
-				let t = e instanceof i.ErrorInfo ? e : void 0;
-				this._emitter.emit("error", new i.ErrorInfo(`unable to process channel message; ${e instanceof Error ? e.message : String(e)}`, b.TransportSubscriptionError, 500, t));
+				this._tree.emitAblyMessage(e);
+				return;
+			}
+			let t = this._decoder.decode(e), n = P(e), r = e.serial, i = n[v];
+			if (i) {
+				for (let e of t) e.kind === "event" && this._handleAmendmentEvent(i, e);
+				return;
 			}
+			let a = n[m];
+			a && this._updateTurnObserverHeaders(a, n, r);
+			for (let i of t) i.kind === "message" ? this._handleMessageOutput(i.message, n, r, e.action) : this._handleEventOutput(i, n);
+			this._tree.emitAblyMessage(e);
+		} catch (e) {
+			let t = e instanceof s.ErrorInfo ? e : void 0;
+			this._emitter.emit("error", new s.ErrorInfo(`unable to process channel message; ${e instanceof Error ? e.message : String(e)}`, O.TransportSubscriptionError, 500, t));
 		}
 	}
 	_handleMessageOutput(e, t, n, r) {
-		let i = t[s];
+		let i = t[h];
 		if (i && this._ownMsgIds.has(i)) {
 			this._upsertAndNotify(e, t, n);
 			return;
@@ -479,7 +859,7 @@ var a = (e) => {
 	}
 	_handleEventOutput(e, t) {
 		if (e.kind !== "event") return;
-		let n = e.event, r = t[o];
+		let n = e.event, r = t[m];
 		if (r) {
 			if (this._router.route(r, n)) {
 				this._accumulateAndEmit(r, e), this._codec.isTerminal(n) && this._turnObservers.delete(r);
@@ -488,9 +868,38 @@ var a = (e) => {
 			this._ownTurnIds.has(r) && !this._turnObservers.has(r) || (this._accumulateAndEmit(r, e), this._codec.isTerminal(n) && this._turnObservers.delete(r));
 		}
 	}
+	_handleAmendmentEvent(e, t) {
+		this._logger.trace("ClientTransport._handleAmendmentEvent();", { targetMsgId: e });
+		let n = this._tree.getNode(e);
+		if (!n) {
+			this._logger.debug("ClientTransport._handleAmendmentEvent(); target not found, dropping", { targetMsgId: e });
+			return;
+		}
+		let r = this._codec.createAccumulator();
+		r.initMessage(e, n.message), r.processOutputs([t]);
+		let i = r.messages.at(-1);
+		i && this._tree.upsert(e, i, n.headers, n.serial);
+	}
+	_handleChannelStateChange(e) {
+		if (this._state === G.CLOSED) return;
+		let { current: t, resumed: n } = e;
+		if (t === "attached" && !this._hasAttachedOnce) {
+			this._hasAttachedOnce = !0;
+			return;
+		}
+		if (!(t === "failed" || t === "suspended" || t === "detached" || t === "attached" && !n)) return;
+		this._logger.error("ClientTransport._handleChannelStateChange(); channel continuity lost", {
+			current: t,
+			resumed: n,
+			previous: e.previous
+		});
+		let r = new s.ErrorInfo(`unable to deliver events; channel continuity lost (${t}${t === "attached" ? ", resumed: false" : ""})`, O.ChannelContinuityLost, 500, e.reason);
+		for (let e of this._ownTurnIds) this._router.errorStream(e, r);
+		this._emitter.emit("error", r);
+	}
 	_upsertAndNotify(e, t, n) {
-		let r = this._codec.getMessageKey(e), i = t["x-ably-msg-id"] ?? r;
-		this._tree.upsert(i, e, t, n), this._emitter.emit("message");
+		let r = t[h];
+		r && this._tree.upsert(r, e, t, n);
 	}
 	_updateTurnObserverHeaders(e, t, n) {
 		let r = this._turnObservers.get(e);
@@ -503,321 +912,445 @@ var a = (e) => {
 	_accumulateAndEmit(e, t) {
 		let n = this._turnObservers.get(e);
 		if (!n) return;
+		let r = n.headers[h];
+		if (r) {
+			let e = this._tree.getNode(r);
+			e && n.accumulator.initMessage(r, e.message);
+		}
 		n.accumulator.processOutputs([t]);
-		let r = n.accumulator.messages;
-		if (r.length === 0) return;
-		let i;
+		let i = n.accumulator.messages;
+		if (i.length === 0) return;
+		let a;
 		try {
-			i = structuredClone(r.at(-1));
+			a = structuredClone(i.at(-1));
 		} catch {
-			i = r.at(-1);
+			a = i.at(-1);
+		}
+		if (a) {
+			let e = n.headers[h];
+			e && this._tree.upsert(e, a, { ...n.headers }, n.serial);
 		}
-		i && (this._tree.upsert(n.headers["x-ably-msg-id"] ?? this._codec.getMessageKey(i), i, { ...n.headers }, n.serial), this._emitter.emit("message"));
 	}
 	async _publishCancel(e) {
 		this._logger.trace("ClientTransport._publishCancel();", { filter: e });
 		let t = {};
-		e.turnId ? t[u] = e.turnId : e.own ? t[d] = "true" : e.clientId ? t[p] = e.clientId : e.all && (t[f] = "true"), await this._channel.publish({
-			name: g,
+		e.turnId ? t[y] = e.turnId : e.own ? t[b] = "true" : e.clientId ? t[S] = e.clientId : e.all && (t[x] = "true"), await this._channel.publish({
+			name: T,
 			extras: { headers: t }
 		});
 	}
 	_closeMatchingTurnStreams(e) {
-		if (e.all) for (let e of this._ownTurnIds) this._router.closeStream(e);
-		else if (e.own) for (let e of this._ownTurnIds) this._router.closeStream(e);
-		else if (e.clientId) for (let [t, n] of this._turnClientIds) n === e.clientId && this._router.closeStream(t);
-		else e.turnId && this._router.closeStream(e.turnId);
+		for (let t of this._getMatchingTurnIds(e)) this._router.closeStream(t);
 	}
 	_getMatchingTurnIds(e) {
-		let t = /* @__PURE__ */ new Set();
-		if (e.all) for (let e of this._turnClientIds.keys()) t.add(e);
-		else if (e.own) for (let [e, n] of this._turnClientIds) n === this._clientId && t.add(e);
-		else if (e.clientId) for (let [n, r] of this._turnClientIds) r === e.clientId && t.add(n);
-		else e.turnId && this._turnClientIds.has(e.turnId) && t.add(e.turnId);
-		return t;
-	}
-	_getMessagesWithHeaders() {
-		return this._tree.flatten().map((e) => ({
-			message: e,
-			headers: this.getMessageHeaders(e)
-		}));
-	}
-	_getHistoryBefore(e) {
-		let t = this._getMessagesWithHeaders(), n = t.findIndex((t) => t.headers?.[s] === e);
-		return n === -1 ? t : t.slice(0, n);
-	}
-	_processHistoryPage(e) {
-		for (let [t, n] of e.items.entries()) {
-			let r = e.itemHeaders?.[t] ?? {}, i = e.itemSerials?.[t], a = this._codec.getMessageKey(n), o = r["x-ably-msg-id"] ?? a;
-			this._tree.upsert(o, n, r, i);
-		}
-		this._emitter.emit("message"), e.rawMessages && e.rawMessages.length > 0 && (this._ablyMessages.unshift(...e.rawMessages), this._emitter.emit("ably-message"));
-	}
-	async _loadUntilVisible(e, t, n) {
-		this._processHistoryPage(e);
-		let r = e, i = () => {
-			let e = 0;
-			for (let t of this._tree.flatten()) n.has(this._codec.getMessageKey(t)) || e++;
-			return e;
-		};
-		for (; i() < t && r.hasNext();) {
-			let e = await r.next();
-			if (!e) break;
-			this._processHistoryPage(e), r = e;
+		let t = /* @__PURE__ */ new Set(), n = this._tree.getActiveTurnIds();
+		if (e.all) for (let e of n.values()) for (let n of e) t.add(n);
+		else if (e.own) {
+			let e = n.get(this._clientId ?? "");
+			if (e) for (let n of e) t.add(n);
+		} else if (e.clientId) {
+			let r = n.get(e.clientId);
+			if (r) for (let e of r) t.add(e);
+		} else if (e.turnId) {
+			for (let r of n.values()) if (r.has(e.turnId)) {
+				t.add(e.turnId);
+				break;
+			}
 		}
-		return {
-			newVisible: this._tree.flatten().filter((e) => !n.has(this._codec.getMessageKey(e))),
-			lastPage: r
-		};
-	}
-	_releaseWithheld(e) {
-		for (let t of e) this._withheldKeys.delete(this._codec.getMessageKey(t));
-		e.length > 0 && this._emitter.emit("message");
+		return t;
 	}
-	async send(e, t) {
-		if (this._closed || (await this._attachPromise, this._closed)) throw new i.ErrorInfo("unable to send; transport is closed", b.TransportClosed, 400);
-		this._logger.trace("ClientTransport.send();");
-		let n = Array.isArray(e) ? e : [e], r = crypto.randomUUID();
-		this._ownTurnIds.add(r);
-		let a = /* @__PURE__ */ new Set(), o = [], c = this._getMessagesWithHeaders(), u;
+	createView() {
+		if (this._state === G.CLOSED) throw new s.ErrorInfo("unable to create view; transport is closed", O.TransportClosed, 400);
+		this._logger.trace("DefaultClientTransport.createView();");
+		let e = W({
+			tree: this._tree,
+			channel: this._channel,
+			codec: this._codec,
+			sendDelegate: this._internalSend.bind(this),
+			logger: this._logger,
+			onClose: () => this._views.delete(e)
+		});
+		return this._views.add(e), e;
+	}
+	async _internalSend(e, t, n, r) {
+		if (this._state === G.CLOSED || (await this._attachPromise, this._state === G.CLOSED)) throw new s.ErrorInfo("unable to send; transport is closed", O.TransportClosed, 400);
+		let i = this._channel.state;
+		if (i !== "attached" && i !== "attaching") throw new s.ErrorInfo(`unable to send; channel is ${i}`, O.ChannelNotReady, 400);
+		this._logger.trace("ClientTransport._internalSend();");
+		let a = Array.isArray(e) ? e : [e], o = crypto.randomUUID();
+		this._ownTurnIds.add(o), this._tree.trackTurn(o, this._clientId ?? "");
+		let c = this._pendingLocalEvents;
+		this._pendingLocalEvents = [], r && r.length > 0 && this._applyEventsToTree(r);
+		let l = [...c, ...r ?? []], u = /* @__PURE__ */ new Set(), d = [], f = n, p;
 		if (t?.parent === void 0 && !t?.forkOf) {
-			let e = this._tree.flatten();
-			if (e.length > 0) {
-				let t = e.at(-1);
-				if (t) {
-					let e = this._codec.getMessageKey(t);
-					u = this._tree.getNodeByKey(e)?.msgId ?? e;
-				}
-			}
+			let e = f.at(-1);
+			e && (p = e.msgId);
 		}
-		let d = t?.parent === void 0 ? u : t.parent;
-		for (let e of n) {
+		let m = t?.parent === void 0 ? p : t.parent;
+		for (let e of a) {
 			let n = crypto.randomUUID();
-			this._ownMsgIds.add(n), a.add(n);
-			let i = t?.parent === void 0 ? u : t.parent ?? void 0, c = L({
+			this._ownMsgIds.add(n), u.add(n);
+			let r = t?.parent === void 0 ? p : t.parent, i = F({
 				role: "user",
-				turnId: r,
+				turnId: o,
 				msgId: n,
 				turnClientId: this._clientId,
-				parent: i,
+				parent: r,
 				forkOf: t?.forkOf
 			});
-			this._upsertAndNotify(e, c);
-			let d = {
-				[s]: n,
-				[l]: "user"
-			};
-			i && (d[m] = i), o.push({
+			this._upsertAndNotify(e, i), d.push({
+				kind: "message",
 				message: e,
-				headers: d
-			}), t?.parent === void 0 && !t?.forkOf && (u = n);
+				msgId: n,
+				parentId: r,
+				forkOf: t?.forkOf,
+				headers: i,
+				serial: void 0
+			}), t?.parent === void 0 && !t?.forkOf && (p = n);
 		}
-		this._turnMsgIds.set(r, a);
-		let f = this._router.createStream(r), p = this._headersFn?.() ?? {}, h = {
+		this._turnMsgIds.set(o, u);
+		let h = this._router.createStream(o), g = this._headersFn?.() ?? {}, _ = {
 			...this._bodyFn?.() ?? {},
-			history: c,
+			history: f,
 			...t?.body,
-			turnId: r,
+			turnId: o,
 			clientId: this._clientId,
-			messages: o,
+			messages: d,
 			...t?.forkOf !== void 0 && { forkOf: t.forkOf },
-			...d !== void 0 && { parent: d }
-		}, g = {
-			...p,
+			...m !== void 0 && { parent: m },
+			...l.length > 0 && { events: l }
+		}, v = {
+			...g,
 			...t?.headers
 		};
 		return this._fetchFn(this._api, {
 			method: "POST",
 			headers: {
 				"Content-Type": "application/json",
-				...g
+				...v
 			},
-			body: JSON.stringify(h),
+			body: JSON.stringify(_),
 			...this._credentials ? { credentials: this._credentials } : {}
 		}).then((e) => {
-			e.ok || (this._emitter.emit("error", new i.ErrorInfo(`unable to send; HTTP POST to ${this._api} returned ${String(e.status)} ${e.statusText}`, b.TransportSendFailed, e.status)), this._router.closeStream(r));
+			if (!e.ok) {
+				let t = new s.ErrorInfo(`unable to send; HTTP POST to ${this._api} returned ${String(e.status)} ${e.statusText}`, O.TransportSendFailed, e.status);
+				this._emitter.emit("error", t), this._router.errorStream(o, t);
+			}
 		}).catch((e) => {
-			let t = e instanceof i.ErrorInfo ? e : void 0;
-			this._emitter.emit("error", new i.ErrorInfo(`unable to send; HTTP POST to ${this._api} failed: ${e instanceof Error ? e.message : String(e)}`, b.TransportSendFailed, 500, t)), this._router.closeStream(r);
+			let t = e instanceof s.ErrorInfo ? e : void 0, n = new s.ErrorInfo(`unable to send; HTTP POST to ${this._api} failed: ${e instanceof Error ? e.message : String(e)}`, O.TransportSendFailed, 500, t);
+			this._emitter.emit("error", n), this._router.errorStream(o, n);
 		}), {
-			stream: f,
-			turnId: r,
-			cancel: async () => this.cancel({ turnId: r })
+			stream: h,
+			turnId: o,
+			cancel: async () => this.cancel({ turnId: o }),
+			optimisticMsgIds: [...u]
 		};
 	}
-	async regenerate(e, t) {
-		this._logger.trace("ClientTransport.regenerate();", { messageId: e });
-		let n = this._tree.getNode(e)?.parentId;
-		return this.send([], {
-			...t,
-			body: {
-				history: this._getHistoryBefore(e),
-				...t?.body
-			},
-			forkOf: e,
-			parent: n
-		});
-	}
-	async edit(e, t, n) {
-		this._logger.trace("ClientTransport.edit();", { messageId: e });
-		let r = this._tree.getNode(e)?.parentId;
-		return this.send(t, {
-			...n,
-			body: {
-				history: this._getHistoryBefore(e),
-				...n?.body
-			},
-			forkOf: e,
-			parent: r
-		});
-	}
 	async cancel(e) {
-		if (this._closed) return;
+		if (this._state === G.CLOSED) return;
 		let t = e ?? { own: !0 };
 		this._logger.debug("ClientTransport.cancel();", { filter: t }), await this._publishCancel(t), this._closeMatchingTurnStreams(t);
 	}
+	stageEvents(e, t) {
+		if (this._logger.trace("ClientTransport.stageEvents();", {
+			msgId: e,
+			eventCount: t.length
+		}), this._state === G.CLOSED) {
+			this._logger.warn("ClientTransport.stageEvents(); transport is closed", { msgId: e });
+			return;
+		}
+		if (!this._tree.getNode(e)) {
+			this._logger.warn("ClientTransport.stageEvents(); msgId not found in tree", { msgId: e });
+			return;
+		}
+		if (t.length === 0) return;
+		let n = {
+			kind: "event",
+			msgId: e,
+			events: t
+		};
+		this._applyEventsToTree([n]), this._pendingLocalEvents.push(n);
+	}
+	stageMessage(e, t) {
+		if (this._logger.trace("ClientTransport.stageMessage();", { msgId: e }), this._state === G.CLOSED) {
+			this._logger.warn("ClientTransport.stageMessage(); transport is closed", { msgId: e });
+			return;
+		}
+		let n = this._tree.getNode(e);
+		if (!n) {
+			this._logger.warn("ClientTransport.stageMessage(); msgId not found in tree", { msgId: e });
+			return;
+		}
+		this._tree.upsert(e, t, n.headers, n.serial);
+	}
+	_applyEventsToTree(e) {
+		for (let t of e) {
+			let e = this._tree.getNode(t.msgId);
+			if (!e) continue;
+			let n = t.events.map((e) => ({
+				kind: "event",
+				event: e,
+				messageId: t.msgId
+			})), r = this._codec.createAccumulator();
+			r.initMessage(t.msgId, e.message), r.processOutputs(n);
+			let i = r.messages.at(-1);
+			i && this._tree.upsert(t.msgId, i, e.headers, e.serial);
+		}
+	}
 	async waitForTurn(e) {
-		if (this._closed) return;
+		if (this._state === G.CLOSED) return;
 		let t = e ?? { own: !0 }, n = this._getMatchingTurnIds(t);
 		if (n.size !== 0) return this._logger.debug("ClientTransport.waitForTurn();", { turnIds: [...n] }), new Promise((e) => {
-			let t = (r) => {
-				r.type === "x-ably-turn-end" && (n.delete(r.turnId), n.size === 0 && (this._emitter.off("turn", t), e()));
-			};
-			this._emitter.on("turn", t);
+			let t = !1, r = () => {
+				if (t) return;
+				t = !0, i();
+				let n = this._closeResolvers.indexOf(r);
+				n !== -1 && this._closeResolvers.splice(n, 1), e();
+			}, i = this._tree.on("turn", (e) => {
+				e.type === "x-ably-turn-end" && (n.delete(e.turnId), n.size === 0 && r());
+			});
+			this._closeResolvers.push(r);
 		});
 	}
 	on(e, t) {
-		if (this._closed) return B;
+		if (this._state === G.CLOSED) return se;
 		let n = t;
 		return this._emitter.on(e, n), () => {
 			this._emitter.off(e, n);
 		};
 	}
-	getTree() {
-		return this._tree;
-	}
-	getActiveTurnIds() {
-		let e = /* @__PURE__ */ new Map();
-		for (let [t, n] of this._turnClientIds) {
-			let r = e.get(n);
-			r || (r = /* @__PURE__ */ new Set(), e.set(n, r)), r.add(t);
-		}
-		return e;
-	}
-	getMessageHeaders(e) {
-		let t = this._codec.getMessageKey(e);
-		return this._tree.getNodeByKey(t)?.headers;
-	}
-	getMessages() {
-		return this._withheldKeys.size === 0 ? this._tree.flatten() : this._tree.flatten().filter((e) => !this._withheldKeys.has(this._codec.getMessageKey(e)));
-	}
-	getMessagesWithHeaders() {
-		return this._getMessagesWithHeaders();
-	}
-	getAblyMessages() {
-		return [...this._ablyMessages];
-	}
-	async history(e) {
-		if (this._closed) throw new i.ErrorInfo("unable to load history; transport is closed", b.TransportClosed, 400);
-		this._logger.trace("ClientTransport.history();", { limit: e?.limit });
-		let t = e?.limit ?? 100, n = new Set(this._tree.flatten().map((e) => this._codec.getMessageKey(e))), r = await I(this._channel, this._codec, e, this._logger), a = await this._loadUntilVisible(r, t, n);
-		r = a.lastPage;
-		let o = a.newVisible;
-		for (let e of o) this._withheldKeys.add(this._codec.getMessageKey(e));
-		let s = o.slice(-t), c = o.slice(0, -t);
-		this._releaseWithheld(s);
-		let l = (e) => ({
-			items: e,
-			hasNext: () => c.length > 0 || r.hasNext(),
-			next: async () => {
-				if (c.length > 0) {
-					let e = c.splice(-t, t);
-					return this._releaseWithheld(e), l(e);
-				}
-				if (!r.hasNext()) return;
-				let e = await r.next();
-				if (!e) return;
-				let i = new Set(n);
-				for (let e of this._tree.flatten()) i.add(this._codec.getMessageKey(e));
-				let a = await this._loadUntilVisible(e, t, i);
-				r = a.lastPage;
-				let o = a.newVisible;
-				for (let e of o) this._withheldKeys.add(this._codec.getMessageKey(e));
-				let s = o.splice(-t, t);
-				if (c.push(...o), this._releaseWithheld(s), s.length !== 0) return l(s);
-			}
-		});
-		return l(s);
-	}
 	async close(e) {
-		if (!this._closed) {
-			if (this._closed = !0, this._logger.info("ClientTransport.close();"), e?.cancel) {
+		if (this._state !== G.CLOSED) {
+			if (this._state = G.CLOSED, this._logger.info("ClientTransport.close();"), e?.cancel) {
 				try {
 					await this._publishCancel(e.cancel);
 				} catch {}
 				this._closeMatchingTurnStreams(e.cancel);
 			}
-			this._channel.unsubscribe(this._onMessage);
+			this._channel.unsubscribe(this._onMessage), this._channel.off(this._onChannelStateChange);
 			for (let e of this._ownTurnIds) this._router.closeStream(e);
-			this._turnObservers.clear(), this._emitter.off(), this._ownTurnIds.clear(), this._ownMsgIds.clear(), this._turnMsgIds.clear(), this._turnClientIds.clear(), this._withheldKeys.clear(), this._ablyMessages.length = 0;
-		}
-	}
-}, H = (e) => new V(e), U = (e) => {
-	let t = n(null);
-	return t.current === null && (t.current = H(e)), t.current;
-}, W = (n) => {
-	let [i, a] = r(() => n.getMessages());
-	return t(() => (a(n.getMessages()), n.on("message", () => {
-		a(n.getMessages());
-	})), [n]), {
-		messages: i,
-		getSiblings: e((e) => n.getTree().getSiblings(e), [n]),
-		hasSiblings: e((e) => n.getTree().hasSiblings(e), [n]),
-		getSelectedIndex: e((e) => n.getTree().getSelectedIndex(e), [n]),
-		selectSibling: e((e, t) => {
-			n.getTree().select(e, t), a(n.getMessages());
-		}, [n])
+			this._turnObservers.clear(), this._emitter.off();
+			for (let e of this._views) e.close();
+			this._views.clear();
+			for (let e of this._closeResolvers) e();
+			this._closeResolvers.length = 0, this._ownTurnIds.clear(), this._ownMsgIds.clear(), this._turnMsgIds.clear();
+		}
+	}
+}, le = (e) => new ce(e), ue = ({ channelName: e, children: t, ...o }) => {
+	let { channel: c } = l({ channelName: e }), p = a(void 0), m = a(e), h = a([]), g = a(!1), _ = a(void 0);
+	if (!(p.current || _.current) || m.current !== e) {
+		m.current = e, p.current && h.current.push(p.current);
+		try {
+			p.current = le({
+				...o,
+				channel: c
+			}), _.current = void 0;
+		} catch (e) {
+			p.current = void 0, _.current = e instanceof s.ErrorInfo ? e : new s.ErrorInfo("Unknown error while creating transport", O.BadRequest, 400);
+		}
+	}
+	let v = n(d), y = p.current, b = _.current, x = i(() => ({
+		transport: y,
+		error: b
+	}), [y, b]), S = i(() => ({
+		...v,
+		[e]: x
+	}), [
+		e,
+		v,
+		x
+	]);
+	return r(() => () => {
+		for (let e of h.current) e.close();
+	}, [e]), r(() => (g.current = !1, () => {
+		g.current = !0, Promise.resolve().then(() => {
+			g.current && p.current?.close();
+		});
+	}), []), /* @__PURE__ */ u(d.Provider, {
+		value: S,
+		children: /* @__PURE__ */ u(f.Provider, {
+			value: x,
+			children: t
+		})
+	});
+}, K = (e) => /* @__PURE__ */ u(c, {
+	channelName: e.channelName,
+	children: /* @__PURE__ */ u(ue, { ...e })
+}), q = ({ transport: e, skip: t } = {}) => {
+	let i = n(f), s = t ? void 0 : e ?? i?.transport, [c, l] = o([]), u = a([]);
+	return r(() => {
+		if (u.current = [], l([]), s) return s.tree.on("ably-message", (e) => {
+			let t = [...u.current, e];
+			u.current = t, l(t);
+		});
+	}, [s]), c;
+}, J = ({ transport: e } = {}) => {
+	let t = n(f), i = e ?? t?.transport, [a, s] = o(() => /* @__PURE__ */ new Map());
+	return r(() => {
+		if (i) return s(i.tree.getActiveTurnIds()), i.tree.on("turn", (e) => {
+			s((t) => {
+				let n = new Map(t);
+				if (e.type === "x-ably-turn-start") {
+					let t = new Set(n.get(e.clientId));
+					t.add(e.turnId), n.set(e.clientId, t);
+				} else {
+					let t = n.get(e.clientId);
+					if (t) {
+						let r = new Set(t);
+						r.delete(e.turnId), r.size === 0 ? n.delete(e.clientId) : n.set(e.clientId, r);
+					}
+				}
+				return n;
+			});
+		});
+	}, [i]), a;
+}, Y = {
+	get tree() {
+		throw new s.ErrorInfo("unable to access tree; hook is skipped", O.InvalidArgument, 400);
+	},
+	get view() {
+		throw new s.ErrorInfo("unable to access view; hook is skipped", O.InvalidArgument, 400);
+	},
+	createView: () => {
+		throw new s.ErrorInfo("unable to create view; hook is skipped", O.InvalidArgument, 400);
+	},
+	cancel: () => {
+		throw new s.ErrorInfo("unable to cancel; hook is skipped", O.InvalidArgument, 400);
+	},
+	stageEvents: () => {
+		throw new s.ErrorInfo("unable to stage events; hook is skipped", O.InvalidArgument, 400);
+	},
+	stageMessage: () => {
+		throw new s.ErrorInfo("unable to stage message; hook is skipped", O.InvalidArgument, 400);
+	},
+	waitForTurn: () => {
+		throw new s.ErrorInfo("unable to wait for turn; hook is skipped", O.InvalidArgument, 400);
+	},
+	on: () => {
+		throw new s.ErrorInfo("unable to subscribe; hook is skipped", O.InvalidArgument, 400);
+	},
+	close: () => {
+		throw new s.ErrorInfo("unable to close; hook is skipped", O.InvalidArgument, 400);
+	}
+}, X = ({ channelName: e, skip: t, onError: i } = {}) => {
+	let o = n(d), c = n(f), l = a(i);
+	l.current = i;
+	let u = t ? void 0 : e === void 0 ? c?.transport : o[e]?.transport;
+	if (r(() => {
+		if (u) return u.on("error", (e) => {
+			l.current?.(e);
+		});
+	}, [u]), t) return { transport: Y };
+	if (e !== void 0) {
+		let t = o[e];
+		return t ? t.transport ? { transport: t.transport } : {
+			transport: Y,
+			transportError: t.error
+		} : {
+			transport: Y,
+			transportError: new s.ErrorInfo(`unable to use transport; no TransportProvider found for channelName "${e}"`, O.BadRequest, 400)
+		};
+	}
+	return c ? c.transport ? { transport: c.transport } : {
+		transport: Y,
+		transportError: c.error
+	} : {
+		transport: Y,
+		transportError: new s.ErrorInfo("unable to use transport; no TransportProvider found in the tree", O.BadRequest, 400)
 	};
-}, G = (t) => e(async (e, n, r) => t.edit(e, n, r), [t]), K = (i, a) => {
-	let [o, s] = r(!1), [c, l] = r(!1), u = n(!1), d = n(null), f = n(i);
-	f.current = i;
-	let p = e(async (e) => {
-		if (!(!f.current || u.current)) {
-			u.current = !0, l(!0);
-			try {
-				let t = await f.current.history(e);
-				d.current = t, s(t.hasNext());
-			} finally {
-				u.current = !1, l(!1);
-			}
+}, Z = ({ transport: e, view: c, limit: l, skip: u } = {}) => {
+	let d = n(f), p = u ? void 0 : e ?? d?.transport, m = u ? void 0 : c ?? p?.view, [h, g] = o(() => m?.flattenNodes() ?? []), [_, v] = o(() => m?.hasOlder() ?? !1), [y, b] = o(!1), [x, S] = o(), C = a(!1), w = l !== void 0, T = a(!1);
+	r(() => {
+		if (!m) {
+			g([]), v(!1), S(void 0);
+			return;
 		}
-	}, []), m = e(async () => {
-		let e = d.current;
-		if (!(!e || !e.hasNext() || u.current || !f.current)) {
-			u.current = !0, l(!0);
+		return T.current = !1, g(m.flattenNodes()), v(m.hasOlder()), S(void 0), m.on("update", () => {
+			g(m.flattenNodes()), v(m.hasOlder());
+		});
+	}, [m]);
+	let E = t(async () => {
+		if (!(!m || C.current)) {
+			C.current = !0, b(!0);
 			try {
-				let t = await e.next();
-				t ? (d.current = t, s(t.hasNext())) : s(!1);
+				await m.loadOlder(l), S(void 0);
+			} catch (e) {
+				e instanceof s.ErrorInfo ? S(e) : S(new s.ErrorInfo("Unknown error loading older messages", O.BadRequest, 400));
 			} finally {
-				u.current = !1, l(!1);
+				C.current = !1, b(!1);
 			}
 		}
-	}, []), h = a != null, g = n(!1), _ = n(a);
-	return _.current = a, t(() => {
-		!h || g.current || !f.current || (g.current = !0, p(_.current ?? void 0));
-	}, [h, p]), {
-		hasNext: o,
-		loading: c,
-		load: p,
-		next: m
+	}, [m, l]);
+	return r(() => {
+		!w || T.current || !m || (T.current = !0, E());
+	}, [
+		w,
+		m,
+		E
+	]), {
+		messages: i(() => h.map((e) => e.message), [h]),
+		nodes: h,
+		hasOlder: _,
+		loading: y,
+		loadError: x,
+		loadOlder: E,
+		select: t((e, t) => {
+			m?.select(e, t);
+		}, [m]),
+		getSelectedIndex: t((e) => m?.getSelectedIndex(e) ?? 0, [m]),
+		getSiblings: t((e) => m?.getSiblings(e) ?? [], [m]),
+		hasSiblings: t((e) => m?.hasSiblings(e) ?? !1, [m]),
+		getNode: t((e) => m?.getNode(e), [m]),
+		send: t(async (e, t) => {
+			if (!m) throw new s.ErrorInfo("unable to send; view is not available", O.InvalidArgument, 400);
+			return m.send(e, t);
+		}, [m]),
+		regenerate: t(async (e, t) => {
+			if (!m) throw new s.ErrorInfo("unable to regenerate; view is not available", O.InvalidArgument, 400);
+			return m.regenerate(e, t);
+		}, [m]),
+		edit: t(async (e, t, n) => {
+			if (!m) throw new s.ErrorInfo("unable to edit; view is not available", O.InvalidArgument, 400);
+			return m.edit(e, t, n);
+		}, [m]),
+		update: t(async (e, t, n) => {
+			if (!m) throw new s.ErrorInfo("unable to update; view is not available", O.InvalidArgument, 400);
+			return m.update(e, t, n);
+		}, [m])
+	};
+}, Q = ({ transport: e, limit: t, skip: i } = {}) => {
+	let a = n(f), s = i ? void 0 : e ?? a?.transport, [c, l] = o();
+	return r(() => {
+		if (!s) {
+			l(void 0);
+			return;
+		}
+		let e = s.createView();
+		return l(e), () => {
+			e.close();
+		};
+	}, [s]), Z({
+		view: c,
+		limit: t,
+		skip: i
+	});
+}, $ = ({ transport: e } = {}) => {
+	let r = n(f), i = e ?? r?.transport;
+	return {
+		getSiblings: t((e) => i?.tree.getSiblings(e) ?? [], [i]),
+		hasSiblings: t((e) => i?.tree.hasSiblings(e) ?? !1, [i]),
+		getNode: t((e) => i?.tree.getNode(e), [i])
 	};
-}, q = (e) => {
-	let [n, i] = r(() => e.getMessages());
-	return t(() => (i(e.getMessages()), e.on("message", () => {
-		i(e.getMessages());
-	})), [e]), n;
-}, J = (t) => e(async (e, n) => t.regenerate(e, n), [t]), Y = (t) => e(async (e, n) => t.send(e, n), [t]);
+}, de = () => ({
+	TransportProvider: K,
+	useClientTransport: (e) => X(e ?? {}),
+	useView: (e) => Z(e ?? {}),
+	useActiveTurns: (e) => J(e ?? {}),
+	useTree: (e) => $(e ?? {}),
+	useAblyMessages: (e) => q(e ?? {}),
+	useCreateView: (e) => Q(e ?? {})
+});
 //#endregion
-export { a as useAblyMessages, y as useActiveTurns, U as useClientTransport, W as useConversationTree, G as useEdit, K as useHistory, q as useMessages, J as useRegenerate, Y as useSend };
+export { f as NearestTransportContext, K as TransportProvider, de as createTransportHooks, q as useAblyMessages, J as useActiveTurns, X as useClientTransport, Q as useCreateView, $ as useTree, Z as useView };
 
 //# sourceMappingURL=ably-ai-transport-react.js.map