@ably/ai-transport 0.1.0 → 0.2.0

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

@@ -1,73 +1,70 @@
-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) => ({
+import * as e from "ably";
+import { useAbly as t } from "ably/react";
+import { createContext as n, useCallback as r, useContext as i, useEffect as a, useMemo as o, useRef as s, useState as c } from "react";
+import { jsx as l } from "react/jsx-runtime";
+var u = "status", d = "run-id", f = "invocation-id", p = "event-id", m = "codec-message-id", h = "run-client-id", g = "input-client-id", _ = "role", v = "parent", y = "fork-of", b = "msg-regenerate", x = "input-codec-message-id", S = "error-code", ee = "ai-cancel", C = /* @__PURE__ */ function(e) {
+	return e[e.BadRequest = 4e4] = "BadRequest", e[e.InvalidArgument = 40003] = "InvalidArgument", e[e.InsufficientCapability = 40160] = "InsufficientCapability", e[e.EncoderRecoveryFailed = 104e3] = "EncoderRecoveryFailed", e[e.SessionSubscriptionError = 104001] = "SessionSubscriptionError", e[e.CancelListenerError = 104002] = "CancelListenerError", e[e.RunLifecycleError = 104003] = "RunLifecycleError", e[e.SessionClosed = 104004] = "SessionClosed", e[e.SessionSendFailed = 104005] = "SessionSendFailed", e[e.ChannelContinuityLost = 104006] = "ChannelContinuityLost", e[e.ChannelNotReady = 104007] = "ChannelNotReady", e[e.StreamError = 104008] = "StreamError", e[e.InputEventNotFound = 104010] = "InputEventNotFound", e;
+}({}), te = (e) => ({
 	logAction: (t, n, r) => {
 		e.error(n, { detail: r });
 	},
 	shouldLog: () => !0
-}), te = s.Realtime.EventEmitter, k = class extends te {
+}), ne = e.Realtime.EventEmitter, w = class extends ne {
 	constructor(e) {
-		super(ee(e));
+		super(te(e));
 	}
-}, A = /* @__PURE__ */ function(e) {
+}, T = /* @__PURE__ */ function(e) {
 	return e.Trace = "trace", e.Debug = "debug", e.Info = "info", e.Warn = "warn", e.Error = "error", e.Silent = "silent", e;
-}({}), ne = (e, t, n) => {
+}({}), re = (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 A.Trace:
-		case A.Debug:
+		case "trace":
+		case "debug":
 			console.log(i);
 			break;
-		case A.Info:
+		case "info":
 			console.info(i);
 			break;
-		case A.Warn:
+		case "warn":
 			console.warn(i);
 			break;
-		case A.Error:
+		case "error":
 			console.error(i);
 			break;
-		case A.Silent: break;
-	}
-}, 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;
-}(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 = 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;
+		case "silent": break;
+	}
+}, ie = (e) => new ae(e.logHandler ?? re, e.logLevel), E = new Map([
+	["trace", 0],
+	["debug", 1],
+	["info", 2],
+	["warn", 3],
+	["error", 4],
+	["silent", 5]
+]), ae = class t {
+	constructor(t, n, r) {
+		this._handler = t, this._context = r;
+		let i = E.get(n);
+		if (i === void 0) throw new e.ErrorInfo(`unable to create logger; invalid log level: ${n}`, C.InvalidArgument, 400);
+		this._levelNumber = i;
 	}
 	trace(e, t) {
-		this._write(e, A.Trace, j.Trace, t);
+		this._write(e, "trace", 0, t);
 	}
 	debug(e, t) {
-		this._write(e, A.Debug, j.Debug, t);
+		this._write(e, "debug", 1, t);
 	}
 	info(e, t) {
-		this._write(e, A.Info, j.Info, t);
+		this._write(e, "info", 2, t);
 	}
 	warn(e, t) {
-		this._write(e, A.Warn, j.Warn, t);
+		this._write(e, "warn", 3, t);
 	}
 	error(e, t) {
-		this._write(e, A.Error, j.Error, t);
+		this._write(e, "error", 4, t);
 	}
-	withContext(t) {
-		let n = [...M.entries()].find(([, e]) => e === this._levelNumber)?.[0] ?? A.Error;
-		return new e(this._handler, n, this._mergeContext(t));
+	withContext(e) {
+		let n = [...E.entries()].find(([, e]) => e === this._levelNumber)?.[0] ?? "error";
+		return new t(this._handler, n, this._mergeContext(e));
 	}
 	_write(e, t, n, r) {
 		n >= this._levelNumber && this._handler(e, t, this._mergeContext(r));
@@ -78,155 +75,219 @@ var d = e({}), f = e(void 0), p = "x-ably-status", m = "x-ably-turn-id", h = "x-
 			...e
 		} : this._context : e ?? void 0;
 	}
-}, P = (e) => {
-	let t = e.extras;
-	if (!t || typeof t != "object") return {};
-	let n = t.headers;
-	return !n || typeof n != "object" ? {} : n;
-}, F = (e) => {
+}, oe = (e, t) => {
+	let n = e.extras;
+	if (!n || typeof n != "object") return {};
+	let r = n.ai;
+	if (!r || typeof r != "object") return {};
+	let i = r[t];
+	return !i || typeof i != "object" ? {} : i;
+}, D = (e) => oe(e, "transport"), O = "0.2.0", k = "ai-transport-js", se = (e, t) => {
+	let n = e;
+	return n.options.agents = {
+		...n.options.agents,
+		...t
+	}, { params: { agent: Object.entries(t).map(([e, t]) => `${e}/${t}`).join(" ") } };
+}, ce = (e, t) => {
+	let n = t?.adapterTag, r = { [k]: O };
+	return n && (r[n] = O), se(e, r);
+}, le = (e) => {
 	let t = {
 		[_]: e.role,
-		[m]: e.turnId,
-		[h]: e.msgId
+		[m]: e.codecMessageId
 	};
-	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._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;
+	return e.runId !== void 0 && (t[d] = e.runId), e.runClientId !== void 0 && (t[h] = e.runClientId), e.parent && (t[v] = e.parent), e.forkOf && (t[y] = e.forkOf), e.regenerates && (t[b] = e.regenerates), e.invocationId && (t[f] = e.invocationId), e.inputClientId !== void 0 && (t[g] = e.inputClientId), e.inputCodecMessageId !== void 0 && (t[x] = e.inputCodecMessageId), e.inputEventId && (t[p] = e.inputEventId), t;
+}, A = (e) => e === "ai-run-start" || e === "ai-run-suspend" || e === "ai-run-resume" || e === "ai-run-end", j = (e, t, n) => {
+	let r = t[d];
+	if (!r) return;
+	let i = t["run-client-id"] ?? "";
+	if (e === "ai-run-start") {
+		let e = t[v], a = t[y], o = t[b];
+		return {
+			type: "start",
+			runId: r,
+			clientId: i,
+			serial: n,
+			invocationId: t["invocation-id"] ?? "",
+			...e !== void 0 && { parent: e },
+			...a !== void 0 && { forkOf: a },
+			...o !== void 0 && { regenerates: o }
+		};
 	}
-	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;
+	if (e === "ai-run-suspend") return {
+		type: "suspend",
+		runId: r,
+		clientId: i,
+		serial: n,
+		invocationId: t["invocation-id"] ?? ""
+	};
+	if (e === "ai-run-resume") return {
+		type: "resume",
+		runId: r,
+		clientId: i,
+		serial: n,
+		invocationId: t["invocation-id"] ?? ""
+	};
+	if (e === "ai-run-end") {
+		let e = t["run-reason"] ?? "complete";
+		return {
+			type: "end",
+			runId: r,
+			clientId: i,
+			serial: n,
+			invocationId: t["invocation-id"] ?? "",
+			reason: e
+		};
 	}
-	has(e) {
-		return this._turns.has(e);
+}, M = (e, t, n) => {
+	let r = D(n), i = n.serial;
+	if (A(n.name)) {
+		let t = j(n.name, r, i);
+		return t && e.applyRunLifecycle(t), t;
+	}
+	let { inputs: a, outputs: o } = t.decode(n);
+	(a.length > 0 || o.length > 0 || r["run-id"]) && e.applyMessage({
+		inputs: a,
+		outputs: o
+	}, r, i);
+}, ue = class e {
+	constructor(e) {
+		this.inputEventId = e.inputEventId, this.sessionName = e.sessionName;
 	}
-}, L = (e, t) => new I(e, t), R = class {
-	get structuralVersion() {
-		return this._structuralVersion;
+	static fromJSON(t) {
+		return new e(t);
 	}
-	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);
+	toJSON() {
+		return {
+			inputEventId: this.inputEventId,
+			sessionName: this.sessionName
+		};
+	}
+}, N = (e) => e.kind === "run" ? e.runId : e.codecMessageId, P = (e) => e.kind === "run" ? e.startSerial : e.serial, F = (e, t, n) => {
+	let r = e.get(t);
+	r || (r = /* @__PURE__ */ new Set(), e.set(t, r)), r.add(n);
+}, I = (e, t, n) => {
+	let r = e.get(t);
+	r && (r.delete(n), r.size === 0 && e.delete(t));
+}, L = class {
+	constructor(e, t) {
+		this._nodeIndex = /* @__PURE__ */ new Map(), this._codecMessageIdToNodeKey = /* @__PURE__ */ new Map(), this._sortedNodes = [], this._parentIndex = /* @__PURE__ */ new Map(), this._replyRunsByInput = /* @__PURE__ */ new Map(), this._seqCounter = 0, this._structuralVersion = 0, this._siblingCache = /* @__PURE__ */ new Map(), this._siblingCacheVersion = -1, this._codec = e, this._logger = t, this._emitter = new w(t);
 	}
 	_compareNodes(e, t) {
-		let n = e.node.serial, r = t.node.serial;
+		let n = P(e.node), r = P(t.node);
 		return n === void 0 && r === void 0 ? e.insertSeq - t.insertSeq : n === void 0 ? 1 : r === void 0 || n < r ? -1 : n > r ? 1 : e.insertSeq - t.insertSeq;
 	}
-	_insertSorted(e) {
-		if (e.node.serial === void 0) {
-			this._sortedList.push(e);
+	_insertSortedNode(e) {
+		if (P(e.node) === void 0) {
+			this._sortedNodes.push(e);
 			return;
 		}
-		let t = 0, n = this._sortedList.length;
+		let t = 0, n = this._sortedNodes.length;
 		for (; t < n;) {
-			let r = t + n >>> 1, i = this._sortedList[r];
+			let r = t + n >>> 1, i = this._sortedNodes[r];
 			if (!i) break;
 			this._compareNodes(i, e) <= 0 ? t = r + 1 : n = r;
 		}
-		this._sortedList.splice(t, 0, e);
+		this._sortedNodes.splice(t, 0, e);
+	}
+	_removeSortedNode(e) {
+		let t = this._sortedNodes.indexOf(e);
+		t !== -1 && this._sortedNodes.splice(t, 1);
 	}
-	_removeSorted(e) {
-		let t = this._sortedList.indexOf(e);
-		t !== -1 && this._sortedList.splice(t, 1);
+	_insertNode(e, t, n) {
+		this._nodeIndex.set(e, t), this._addToParentIndex(n, e), this._insertSortedNode(t), this._structuralVersion++;
+	}
+	_promoteSerial(e) {
+		this._removeSortedNode(e), this._insertSortedNode(e), this._structuralVersion++;
+	}
+	_foldInto(e, t, n, r) {
+		for (let i of t) try {
+			e.node.projection = this._codec.fold(e.node.projection, i, {
+				serial: n ?? "",
+				messageId: r
+			});
+		} catch (t) {
+			this._logger.error("Tree._foldInto(); fold threw", {
+				key: N(e.node),
+				messageId: r,
+				err: t
+			});
+		}
 	}
 	_addToParentIndex(e, t) {
-		let n = this._parentIndex.get(e);
-		n || (n = /* @__PURE__ */ new Set(), this._parentIndex.set(e, n)), n.add(t);
+		F(this._parentIndex, e, t);
 	}
 	_removeFromParentIndex(e, t) {
-		let n = this._parentIndex.get(e);
-		n && (n.delete(t), n.size === 0 && this._parentIndex.delete(e));
+		I(this._parentIndex, e, t);
+	}
+	_parentKeyOf(e) {
+		let t = e.parentCodecMessageId;
+		return t === void 0 ? void 0 : this._codecMessageIdToNodeKey.get(t);
+	}
+	_inputGroupRoot(e) {
+		let t = e, n = new Set([N(t)]);
+		for (; t.forkOf !== void 0 && !n.has(t.forkOf);) {
+			let e = this._nodeIndex.get(t.forkOf);
+			if (e?.node.kind !== "input" || e.node.parentCodecMessageId !== t.parentCodecMessageId) break;
+			t = e.node, n.add(N(t));
+		}
+		return t;
 	}
 	_getSiblingGroup(e) {
-		let t = this._nodeIndex.get(e);
-		if (!t) return [];
-		let n = t.node, r = new Set([n.msgId]);
-		for (; n.forkOf && !r.has(n.forkOf);) {
-			let e = this._nodeIndex.get(n.forkOf);
-			if (!e || e.node.parentId !== n.parentId) break;
-			n = e.node, r.add(n.msgId);
-		}
-		let i = n.parentId, a = n.msgId, o = [], s = this._parentIndex.get(i);
-		if (s) for (let e of s) {
+		this._siblingCacheVersion !== this._structuralVersion && (this._siblingCache.clear(), this._siblingCacheVersion = this._structuralVersion);
+		let t = this._siblingCache.get(e);
+		if (t) return t;
+		let n = this._nodeIndex.get(e);
+		if (!n) return [];
+		let r = n.node;
+		r.kind === "input" && (r = this._inputGroupRoot(r));
+		let i = r.parentCodecMessageId, a = [], o = this._parentIndex.get(i);
+		if (o) for (let e of o) {
 			let t = this._nodeIndex.get(e);
-			t && this._isSiblingOf(t.node, a) && o.push(t);
+			t && this._isSiblingOf(t.node, r) && a.push(t);
 		}
-		return o.sort((e, t) => this._compareNodes(e, t)), o.map((e) => e.node);
+		a.sort((e, t) => this._compareNodes(e, t));
+		for (let e of a) this._siblingCache.set(N(e.node), a);
+		return this._siblingCache.set(e, a), a;
 	}
 	_isSiblingOf(e, t) {
-		if (e.msgId === t) return !0;
-		let n = e, r = new Set([n.msgId]);
-		for (; n.forkOf;) {
-			if (n.forkOf === t) return !0;
-			if (r.has(n.forkOf)) break;
-			let e = this._nodeIndex.get(n.forkOf);
+		if (e.kind !== t.kind || e.parentCodecMessageId !== t.parentCodecMessageId) return !1;
+		if (e.kind === "run") return !0;
+		let n = N(t);
+		if (N(e) === n) return !0;
+		let r = e, i = new Set([N(r)]);
+		for (; r.kind === "input" && r.forkOf !== void 0;) {
+			if (r.forkOf === n) return !0;
+			if (i.has(r.forkOf)) break;
+			let e = this._nodeIndex.get(r.forkOf);
 			if (!e) break;
-			n = e.node, r.add(n.msgId);
+			r = e.node, i.add(N(r));
 		}
 		return !1;
 	}
 	getGroupRoot(e) {
 		let t = this._nodeIndex.get(e);
 		if (!t) return e;
-		let n = t.node, r = new Set([n.msgId]);
-		for (; n.forkOf && !r.has(n.forkOf);) {
-			let e = this._nodeIndex.get(n.forkOf);
-			if (!e || e.node.parentId !== n.parentId) break;
-			n = e.node, r.add(n.msgId);
-		}
-		return n.msgId;
+		if (t.node.kind === "input") return N(this._inputGroupRoot(t.node));
+		let n = this._getSiblingGroup(e)[0]?.node;
+		return n ? N(n) : e;
 	}
-	flattenNodes(e) {
-		this._logger.trace("DefaultTree.flattenNodes();");
+	visibleNodes(e = /* @__PURE__ */ new Map()) {
+		this._logger.trace("DefaultTree.visibleNodes();");
 		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;
+		for (let i of this._sortedNodes) {
+			let a = i.node, o = N(a), s = this._parentKeyOf(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;
+					if (i !== void 0 && c.some((e) => N(e.node) === i)) n = i;
 					else {
 						let e = c.at(-1);
 						if (!e) break;
-						n = e.msgId;
+						n = N(e.node);
 					}
 					r.set(t, n);
 				}
@@ -236,64 +297,185 @@ var d = e({}), f = e(void 0), p = "x-ably-status", m = "x-ably-turn-id", h = "x-
 		}
 		return t;
 	}
-	getSiblings(e) {
-		return this._logger.trace("DefaultTree.getSiblings();", { msgId: e }), this._getSiblingGroup(e).map((e) => e.message);
+	getRunNode(e) {
+		this._logger.trace("DefaultTree.getRunNode();", { runId: e });
+		let t = this._nodeIndex.get(e)?.node;
+		return t?.kind === "run" ? t : void 0;
 	}
-	getSiblingNodes(e) {
-		return this._getSiblingGroup(e);
+	getNode(e) {
+		return this._logger.trace("DefaultTree.getNode();", { key: e }), this._nodeIndex.get(e)?.node;
 	}
-	hasSiblings(e) {
-		return this._getSiblingGroup(e).length > 1;
+	getNodeByCodecMessageId(e) {
+		this._logger.trace("DefaultTree.getNodeByCodecMessageId();", { codecMessageId: e });
+		let t = this._codecMessageIdToNodeKey.get(e);
+		return t === void 0 ? void 0 : this._nodeIndex.get(t)?.node;
 	}
-	getNode(e) {
-		return this._logger.trace("DefaultTree.getNode();", { msgId: e }), this._nodeIndex.get(e)?.node;
-	}
-	getHeaders(e) {
-		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, 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("Tree.upsert(); promoting serial", {
-				msgId: e,
-				serial: r
-			}), o.node.serial = r, this._removeSorted(o), this._insertSorted(o), this._structuralVersion++), this._emitter.emit("update");
+	getReplyRuns(e) {
+		let t = this._replyRunsByInput.get(e);
+		if (!t) return [];
+		let n = [];
+		for (let e of t) {
+			let t = this._nodeIndex.get(e)?.node;
+			t?.kind === "run" && n.push(t);
+		}
+		return n;
+	}
+	getSiblingNodes(e) {
+		return this._logger.trace("DefaultTree.getSiblingNodes();", { key: e }), this._getSiblingGroup(e).map((e) => e.node);
+	}
+	applyMessage(e, t, n) {
+		let r = t[d], i = t[m], a = r === void 0 && i !== void 0 && t.role === "user" && e.inputs.length > 0 ? i : void 0;
+		if (r === void 0 && a === void 0) {
+			this._logger.warn("Tree.applyMessage(); message has no run-id and is not a user input; skipping");
 			return;
 		}
-		this._logger.trace("Tree.upsert(); inserting new node", {
-			msgId: e,
-			parentId: i,
-			forkOf: a
+		let o = [...e.inputs, ...e.outputs], s = a ?? r;
+		if (o.length === 0 && s !== void 0 && !this._nodeIndex.has(s)) return;
+		let c = this._structuralVersion;
+		a === void 0 ? r !== void 0 && this._applyRunMessage(r, e, t, n) : this._applyInputMessage(a, t, n, o), this._structuralVersion !== c && this._emitter.emit("update");
+	}
+	_applyInputMessage(e, t, n, r) {
+		let i = this._nodeIndex.get(e);
+		i ? i.node.kind === "input" && n && !i.node.serial && (this._logger.debug("Tree.applyMessage(); promoting input serial", {
+			codecMessageId: e,
+			serial: n
+		}), i.node.serial = n, this._promoteSerial(i)) : (i = this._createInputNodeFromHeaders(e, t, n), this._insertNode(e, i, i.node.parentCodecMessageId), this._codecMessageIdToNodeKey.set(e, e), this._logger.debug("Tree.applyMessage(); created input node", { codecMessageId: e })), this._foldInto(i, r, n, e), this._emitter.emit("output", {
+			runId: void 0,
+			inputCodecMessageId: e,
+			codecMessageId: e,
+			serial: n,
+			events: []
+		});
+	}
+	_applyRunMessage(e, t, n, r) {
+		let i = n[m], a = n[x], o = [...t.inputs, ...t.outputs], s = t.outputs, c = this._nodeIndex.get(e);
+		if (!c && i !== void 0) {
+			let e = this._codecMessageIdToNodeKey.get(i), t = e === void 0 ? void 0 : this._nodeIndex.get(e);
+			t?.node.kind === "run" && t.node.startSerial === void 0 && (c = t);
+		}
+		c ? r && c.node.kind === "run" && !c.node.startSerial && (this._logger.debug("Tree.applyMessage(); promoting startSerial", {
+			runId: e,
+			serial: r
+		}), c.node.startSerial = r, this._promoteSerial(c)) : (c = this._createRunFromHeaders(e, n, r), this._insertNode(e, c, c.node.parentCodecMessageId), this._indexReplyRun(c.node, e), this._logger.debug("Tree.applyMessage(); created new Run", { runId: e }));
+		let l = N(c.node);
+		i && this._codecMessageIdToNodeKey.set(i, l), this._foldInto(c, o, r, i), this._emitter.emit("output", {
+			runId: l,
+			inputCodecMessageId: a,
+			codecMessageId: i,
+			serial: r,
+			events: s
+		});
+	}
+	_indexReplyRun(e, t) {
+		e.parentCodecMessageId !== void 0 && F(this._replyRunsByInput, e.parentCodecMessageId, t);
+	}
+	applyRunLifecycle(e) {
+		this._logger.trace("DefaultTree.applyRunLifecycle();", {
+			type: e.type,
+			runId: e.runId
 		});
-		let s = {
+		let t = this._structuralVersion;
+		switch (e.type) {
+			case "start":
+				this._applyRunStart(e);
+				break;
+			case "suspend":
+				this._applyRunSuspend(e);
+				break;
+			case "resume":
+				this._applyRunResume(e);
+				break;
+			case "end":
+				this._applyRunEnd(e);
+				break;
+		}
+		this._emitter.emit("run", e), this._structuralVersion !== t && this._emitter.emit("update");
+	}
+	_applyRunStart(e) {
+		let t = this._nodeIndex.get(e.runId);
+		if (t?.node.kind === "run") {
+			let n = t.node;
+			if (n.status !== "active" && (n.status = "active"), e.serial && !n.startSerial && (n.startSerial = e.serial, this._promoteSerial(t)), n.parentCodecMessageId === void 0 && e.parent !== void 0 && (n.parentCodecMessageId = e.parent, this._removeFromParentIndex(void 0, e.runId), this._addToParentIndex(n.parentCodecMessageId, e.runId), this._indexReplyRun(n, e.runId), this._structuralVersion++), n.forkOf === void 0 && e.forkOf !== void 0) {
+				let t = this._codecMessageIdToNodeKey.get(e.forkOf);
+				t !== void 0 && t !== e.runId && (n.forkOf = t, this._structuralVersion++);
+			}
+			n.regeneratesCodecMessageId === void 0 && e.regenerates !== void 0 && (n.regeneratesCodecMessageId = e.regenerates, this._structuralVersion++), n.invocationId === "" && e.invocationId !== "" && (n.invocationId = e.invocationId);
+		} else if (!t) {
+			let t = this._createRunFromLifecycle(e);
+			this._insertNode(e.runId, t, t.node.parentCodecMessageId), this._indexReplyRun(t.node, e.runId);
+		}
+	}
+	_applyRunSuspend(e) {
+		let t = this._nodeIndex.get(e.runId);
+		t?.node.kind === "run" && (t.node.status = "suspended", t.node.endSerial = e.serial);
+	}
+	_applyRunResume(e) {
+		let t = this._nodeIndex.get(e.runId);
+		t?.node.kind === "run" && t.node.status === "suspended" && (t.node.status = "active");
+	}
+	_applyRunEnd(e) {
+		let t = this._nodeIndex.get(e.runId);
+		t?.node.kind === "run" && (t.node.status = e.reason, t.node.endSerial = e.serial);
+	}
+	delete(e) {
+		let t = this._nodeIndex.get(e);
+		t && (this._logger.debug("Tree.delete();", { key: e }), this._removeFromParentIndex(t.node.parentCodecMessageId, e), this._removeSortedNode(t), this._nodeIndex.delete(e), t.node.kind === "run" && t.node.parentCodecMessageId !== void 0 && I(this._replyRunsByInput, t.node.parentCodecMessageId, e), this._structuralVersion++, this._emitter.emit("update"));
+	}
+	_createRunFromHeaders(e, t, n) {
+		let r = t[y];
+		return this._buildRunNode({
+			runId: e,
+			parentCodecMessageId: t[v],
+			forkOf: r ? this._codecMessageIdToNodeKey.get(r) : void 0,
+			regeneratesCodecMessageId: t[b],
+			clientId: t["run-client-id"] ?? "",
+			invocationId: t["invocation-id"] ?? "",
+			startSerial: n
+		});
+	}
+	_buildRunNode(e) {
+		return {
 			node: {
-				kind: "message",
-				message: t,
-				msgId: e,
-				parentId: i,
-				forkOf: a,
-				headers: { ...n },
-				serial: r
+				kind: "run",
+				runId: e.runId,
+				parentCodecMessageId: e.parentCodecMessageId,
+				forkOf: e.forkOf,
+				regeneratesCodecMessageId: e.regeneratesCodecMessageId,
+				clientId: e.clientId,
+				invocationId: e.invocationId,
+				status: "active",
+				projection: this._codec.init(),
+				startSerial: e.startSerial,
+				endSerial: void 0
 			},
 			insertSeq: this._seqCounter++
 		};
-		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("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");
+	_createInputNodeFromHeaders(e, t, n) {
+		let r = t[y];
+		return {
+			node: {
+				kind: "input",
+				codecMessageId: e,
+				parentCodecMessageId: t[v],
+				forkOf: r,
+				projection: this._codec.init(),
+				serial: n
+			},
+			insertSeq: this._seqCounter++
+		};
 	}
-	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;
+	_createRunFromLifecycle(e) {
+		let t = e.forkOf;
+		return this._buildRunNode({
+			runId: e.runId,
+			parentCodecMessageId: e.parent,
+			forkOf: t ? this._codecMessageIdToNodeKey.get(t) : void 0,
+			regeneratesCodecMessageId: e.regenerates,
+			clientId: e.clientId,
+			invocationId: e.invocationId,
+			startSerial: e.serial
+		});
 	}
 	on(e, t) {
 		let n = t;
@@ -304,165 +486,101 @@ var d = e({}), f = e(void 0), p = "x-ably-status", m = "x-ably-turn-id", h = "x-
 	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);
-	}
-}, 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 = 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 = {
-				accumulator: e.codec.createAccumulator(),
-				firstSeen: a++,
-				msgHeaders: /* @__PURE__ */ new Map(),
-				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 }), g && n.msgSerials.set(p, g));
-			}
-			n.accumulator.processOutputs(t);
-		} 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 [e, t] of i.completedMessages.entries()) {
-		let n = c[e];
-		u.push({
-			message: t,
-			headers: n ? o.get(n) ?? {} : {},
-			serial: n ? s.get(n) ?? "" : ""
-		});
-	}
-	let d = [...r.values()].toSorted((e, t) => e.firstSeen - t.firstSeen);
-	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();
-}, 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) => {
+}, R = (e, t) => new L(e, t), z = (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);
+		let t = D(n), r = t[m];
+		if (!r) continue;
+		let i = n.action, a = i === "message.create" && "discrete" in t, o = t.stream === "true" && (i === "message.create" || i === "message.update" || i === "message.append"), s = t[u], c = s === "complete" || s === "cancelled";
+		(a || o) && e.startedCodecMessageIds.add(r), (a || c) && e.terminatedCodecMessageIds.add(r), e.startedCodecMessageIds.has(r) && e.terminatedCodecMessageIds.has(r) && e.completedCodecMessageIds.add(r);
 	}
-}, H = async (e, t, n) => {
-	e.rawMessages.push(...t.items), e.lastAblyPage = t, V(e, t.items);
+}, B = async (e, t, n) => {
+	e.rawMessages.push(...t.items), e.lastAblyPage = t, z(e, t.items);
 	let r = e.returnedCount + n;
-	for (; e.completedMsgIds.size < r && t.hasNext();) {
-		e.logger.debug("decodeHistory.fetchUntilLimit(); fetching next page", {
+	for (; e.completedCodecMessageIds.size < r && t.hasNext();) {
+		e.logger.debug("loadHistory.fetchUntilLimit(); fetching next page", {
 			collected: e.rawMessages.length,
-			completed: e.completedMsgIds.size
+			completed: e.completedCodecMessageIds.size
 		});
 		let n = await t.next();
 		if (!n) break;
-		t = n, e.rawMessages.push(...n.items), e.lastAblyPage = n, V(e, n.items);
+		t = n, e.rawMessages.push(...n.items), e.lastAblyPage = n, z(e, n.items);
 	}
-}, 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() : [];
+}, V = (e, t) => {
+	let n = e.completedCodecMessageIds.size, r = Math.min(t, Math.max(0, n - e.returnedCount));
+	e.returnedCount += r;
+	let i = n > e.returnedCount, a = e.lastAblyPage?.hasNext() ?? !1, o = e.rawMessages.length - e.returnedRawCount > 0 ? e.rawMessages.slice(e.returnedRawCount).toReversed() : [];
 	return e.returnedRawCount = e.rawMessages.length, {
-		items: i.map((e) => ({
-			message: e.message,
-			headers: e.headers,
-			serial: e.serial
-		})),
-		rawMessages: s,
-		hasNext: () => a || o,
+		rawMessages: o,
+		hasNext: () => i || a,
 		next: async () => {
-			if (a) return U(e, t);
-			if (!o || !e.lastAblyPage) return;
+			if (i) return V(e, t);
+			if (!a || !e.lastAblyPage) return;
 			let n = await e.lastAblyPage.next();
-			if (n) return await H(e, n, t), U(e, t);
+			if (n) return await B(e, n, t), V(e, t);
 		}
 	};
-}, ae = async (e, t, n, r) => {
-	let i = n?.limit ?? 100, a = {
-		codec: t,
+}, H = async (e, t, n) => {
+	let r = t?.limit ?? 100, i = {
 		rawMessages: [],
 		returnedCount: 0,
 		returnedRawCount: 0,
 		lastAblyPage: void 0,
-		cachedDecode: void 0,
-		cachedAtRawLength: 0,
-		startedMsgIds: /* @__PURE__ */ new Set(),
-		terminatedMsgIds: /* @__PURE__ */ new Set(),
-		completedMsgIds: /* @__PURE__ */ new Set(),
-		logger: r
+		startedCodecMessageIds: /* @__PURE__ */ new Set(),
+		terminatedCodecMessageIds: /* @__PURE__ */ new Set(),
+		completedCodecMessageIds: /* @__PURE__ */ new Set(),
+		logger: n
 	};
-	r.trace("decodeHistory();", { limit: i });
-	let o = i * 10;
-	return await e.attach(), await H(a, await e.history({
+	n.trace("loadHistory();", { limit: r });
+	let a = r * 10;
+	return await e.attach(), await B(i, await e.history({
 		untilAttach: !0,
-		limit: o
-	}), i), U(a, i);
-}, oe = class {
+		limit: a
+	}), r), V(i, r);
+}, de = (e) => Array.isArray(e) ? e : [e], fe = 3, U = (e) => ({
+	runId: e.runId,
+	clientId: e.clientId,
+	status: e.status,
+	invocationId: e.invocationId
+}), pe = 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._branchSelections = /* @__PURE__ */ new Map(), this._regenSelections = /* @__PURE__ */ new Map(), this._withheldRunIds = /* @__PURE__ */ new Set(), this._lastVisibleNodeKeys = [], this._lastVisibleProjections = [], this._lastVisibleMessagePairs = [], this._lastVisibleNodeKeySet = /* @__PURE__ */ new Set(), this._hasMoreHistory = !1, this._withheldBuffer = [], this._unsubs = [], this._cachedNodes = [], 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 w(this._logger), this._cachedNodes = this._computeFlatNodes(), 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);
+		}), this._tree.on("run", (e) => {
+			this._onTreeRun(e);
+		}), this._tree.on("output", (e) => {
+			this._onTreeOutput(e);
 		}));
 	}
+	_onTreeOutput(e) {
+		this._processingHistory || (e.runId !== void 0 && this._lastVisibleNodeKeySet.has(e.runId) || e.inputCodecMessageId !== void 0 && this._lastVisibleNodeKeySet.has(e.inputCodecMessageId)) && (this._lastVisibleProjections = this._cachedNodes.map((e) => e.projection), this._lastVisibleMessagePairs = this._extractMessages(this._cachedNodes), this._emitter.emit("update"));
+	}
 	getMessages() {
-		return this.flattenNodes().map((e) => e.message);
+		return this._lastVisibleMessagePairs;
 	}
-	flattenNodes() {
-		return this._cachedNodes;
+	runs() {
+		return this._cachedNodes.filter((e) => e.kind === "run").map((e) => U(e));
 	}
 	_computeFlatNodes() {
-		let e = this._tree.flattenNodes(this._resolveSelections());
-		return this._withheldMsgIds.size === 0 ? e : e.filter((e) => !this._withheldMsgIds.has(e.msgId));
+		let e = this._treeVisibleNodes();
+		return this._withheldRunIds.size === 0 ? e : e.filter((e) => !this._withheldRunIds.has(N(e)));
+	}
+	_recomputeAndEmit() {
+		this._cachedNodes = this._computeFlatNodes(), this._updateVisibleSnapshot(this._cachedNodes), this._emitter.emit("update");
+	}
+	_recomputeAndEmitIfChanged() {
+		let e = this._computeFlatNodes();
+		this._visibleChanged(e) && (this._cachedNodes = e, this._updateVisibleSnapshot(e), this._emitter.emit("update"));
+	}
+	_runByCodecMessageId(e) {
+		let t = this._tree.getNodeByCodecMessageId(e);
+		return t?.kind === "run" ? t : void 0;
+	}
+	_extractMessages(e) {
+		let t = [];
+		for (let n of e) for (let e of this._codec.getMessages(n.projection)) t.push(e);
+		return t;
 	}
 	hasOlder() {
 		return this._withheldBuffer.length > 0 || this._hasMoreHistory;
@@ -490,7 +608,7 @@ var d = e({}), f = e(void 0), p = "x-ably-status", m = "x-ably-turn-id", h = "x-
 					t || (this._hasMoreHistory = !1);
 					return;
 				}
-				await this._loadAndReveal(t, e);
+				await this._revealFromPage(t, e);
 			} catch (e) {
 				throw this._logger.error("DefaultView.loadOlder(); failed", { error: e }), e;
 			} finally {
@@ -498,132 +616,182 @@ var d = e({}), f = e(void 0), p = "x-ably-status", m = "x-ably-turn-id", h = "x-
 			}
 		}
 	}
-	select(e, t) {
-		this._logger.trace("DefaultView.select();", {
-			msgId: e,
+	runOf(e) {
+		this._logger.trace("DefaultView.runOf();", { codecMessageId: e });
+		let t = this._tree.getNodeByCodecMessageId(e);
+		if (!t) return;
+		if (t.kind === "run") return U(t);
+		let n = this._selectedReplyRun(t.codecMessageId);
+		return n ? U(n) : void 0;
+	}
+	_selectedReplyRun(e) {
+		let t = this._tree.getReplyRuns(e);
+		if (t.length === 0) return;
+		if (t.length === 1) return t[0];
+		let n = this._tree.getGroupRoot(t[0]?.runId ?? ""), r = this._regenSelections.get(n), i = r && r.kind !== "pending" ? r.selectedRunId : void 0;
+		if (i !== void 0) {
+			let e = t.find((e) => e.runId === i);
+			if (e) return e;
+		}
+		return t.toSorted((e, t) => (e.startSerial ?? "￿").localeCompare(t.startSerial ?? "￿")).at(-1);
+	}
+	run(e) {
+		this._logger.trace("DefaultView.run();", { runId: e });
+		let t = this._tree.getRunNode(e);
+		return t ? U(t) : void 0;
+	}
+	branchSelection(e) {
+		let t = this._resolveMessageBranchPoint(e);
+		if (t) {
+			let e = t.siblings.flatMap((e) => {
+				let t = this._codec.getMessages(e.projection).at(0);
+				return t ? [t.message] : [];
+			});
+			if (e.length > 0) {
+				let n = this._resolveSelectedIndex(t), r = Math.max(0, Math.min(n, e.length - 1)), i = e[r];
+				return {
+					hasSiblings: e.length > 1,
+					siblings: e,
+					index: r,
+					selected: i
+				};
+			}
+		}
+		let n = this._tree.getNodeByCodecMessageId(e);
+		if (n) {
+			let t = this._codec.getMessages(n.projection).find((t) => t.codecMessageId === e);
+			if (t !== void 0) return {
+				hasSiblings: !1,
+				siblings: [t.message],
+				index: 0,
+				selected: t.message
+			};
+		}
+		return {
+			hasSiblings: !1,
+			siblings: [],
+			index: 0,
+			selected: void 0
+		};
+	}
+	selectSibling(e, t) {
+		this._logger.trace("DefaultView.selectSibling();", {
+			codecMessageId: 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, {
+		let n = this._resolveMessageBranchPoint(e);
+		if (!n) return;
+		let r = Math.max(0, Math.min(t, n.siblings.length - 1)), i = n.siblings[r];
+		i && (n.kind === "fork-of" ? (this._branchSelections.set(n.groupRoot, {
+			kind: "user",
+			selectedKey: N(i)
+		}), this._logger.debug("DefaultView.selectSibling(); fork-of", {
+			codecMessageId: e,
+			index: r,
+			selectedKey: N(i)
+		})) : (this._regenSelections.set(n.groupRoot, {
 			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);
+			selectedRunId: N(i)
+		}), this._logger.debug("DefaultView.selectSibling(); regenerate", {
+			codecMessageId: e,
+			index: r,
+			selectedRunId: N(i),
+			groupRoot: n.groupRoot
+		})), this._recomputeAndEmit());
+	}
+	_resolveSelectedIndex(e) {
+		if (e.kind === "fork-of") {
+			let t = this._branchSelections.get(e.groupRoot);
+			if (!t) return e.siblings.length - 1;
+			let n = e.siblings.findIndex((e) => N(e) === t.selectedKey);
+			return n === -1 ? e.siblings.length - 1 : n;
+		}
+		let t = this._regenSelections.get(e.groupRoot);
+		if (!t || t.kind === "pending") return e.siblings.length - 1;
+		let n = e.siblings.findIndex((e) => N(e) === t.selectedRunId);
+		return n === -1 ? e.siblings.length - 1 : n;
 	}
-	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);
-			}
+	_resolveMessageBranchPoint(e) {
+		let t = this._tree.getNodeByCodecMessageId(e);
+		if (!t) return;
+		if (t.kind === "input") {
+			let e = this._tree.getSiblingNodes(t.codecMessageId);
+			return e.length > 1 ? {
+				kind: "fork-of",
+				groupRoot: this._tree.getGroupRoot(t.codecMessageId),
+				siblings: e
+			} : void 0;
 		}
-		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
-		});
+		let n = this._tree.getSiblingNodes(t.runId);
+		if (n.length > 1 && this._codec.getMessages(t.projection).at(0)?.codecMessageId === e) return {
+			kind: "regen",
+			groupRoot: this._tree.getGroupRoot(t.runId),
+			siblings: n
+		};
 	}
-	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, {
+	async send(t, n) {
+		if (this._logger.trace("DefaultView.send();"), this._closed) throw new e.ErrorInfo("unable to send; view is closed", C.InvalidArgument, 400);
+		let r = de(t), i = this._lastVisibleMessagePairs.at(-1)?.codecMessageId, a = await this._sendDelegate(r, n, i);
+		return this._applyForkAutoSelect(a, n), a;
+	}
+	_applyForkAutoSelect(e, t) {
+		if (!t?.forkOf) return;
+		let n = e.optimisticCodecMessageIds.at(0);
+		if (n === void 0) return;
+		let r = this._tree.getGroupRoot(n);
+		this._branchSelections.set(r, {
+			kind: "auto",
+			selectedKey: n
+		}), this._recomputeAndEmit();
+	}
+	_applyRegenerateAutoSelect(e, t) {
+		let n = this._runByCodecMessageId(t);
+		if (!n) return;
+		let r = this._tree.getGroupRoot(n.runId);
+		this._regenSelections.set(r, {
+			kind: "pending",
+			carrierCodecMessageId: e.inputCodecMessageId
+		}), this._logger.debug("DefaultView._applyRegenerateAutoSelect(); deferring regenerate selection", {
+			anchorCodecMessageId: t,
+			groupRoot: r,
+			carrier: e.inputCodecMessageId
+		}), this._resolvePendingRegenSelections(), this._recomputeAndEmitIfChanged();
+	}
+	async regenerate(t, n) {
+		if (this._logger.trace("DefaultView.regenerate();", { messageId: t }), this._closed) throw new e.ErrorInfo("unable to regenerate; view is closed", C.InvalidArgument, 400);
+		let r = this._runByCodecMessageId(t);
+		if (!r) throw new e.ErrorInfo(`unable to regenerate; message not found in tree: ${t}`, C.InvalidArgument, 400);
+		let i = this._findParentMsgId(r, t);
+		if (!i) throw new e.ErrorInfo(`unable to regenerate; parent user message not found for ${t}`, C.InvalidArgument, 400);
+		let a = t;
+		r.regeneratesCodecMessageId !== void 0 && this._codec.getMessages(r.projection).at(0)?.codecMessageId === t && (a = r.regeneratesCodecMessageId);
+		let o = {
 			...n,
-			body: {
-				history: this._getHistoryBefore(e),
-				...n?.body
-			},
-			forkOf: e,
 			parent: i
+		}, s = this._codec.createRegenerate(a, i), c = await this._sendDelegate([s], o, i);
+		return this._applyRegenerateAutoSelect(c, a), c;
+	}
+	async edit(t, n, r) {
+		if (this._logger.trace("DefaultView.edit();", { messageId: t }), this._closed) throw new e.ErrorInfo("unable to edit; view is closed", C.InvalidArgument, 400);
+		let i = this._tree.getNodeByCodecMessageId(t);
+		if (!i) throw new e.ErrorInfo(`unable to edit; message not found in tree: ${t}`, C.InvalidArgument, 400);
+		let a = this._findParentMsgId(i, t);
+		return this.send(n, {
+			...r,
+			forkOf: t,
+			parent: a
 		});
 	}
-	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);
+	_findParentMsgId(e, t) {
+		let n = this._lastVisibleMessagePairs, r = n.findIndex((e) => e.codecMessageId === t);
+		if (r > 0) return n[r - 1]?.codecMessageId;
+		if (r === 0) return;
+		let i = this._codec.getMessages(e.projection), a = i.findIndex((e) => e.codecMessageId === t);
+		if (a > 0) return i[a - 1]?.codecMessageId;
+		if (a === 0 && e.parentCodecMessageId !== void 0) {
+			let t = this._tree.getNodeByCodecMessageId(e.parentCodecMessageId);
+			if (t) return this._codec.getMessages(t.projection).at(-1)?.codecMessageId;
 		}
-		return t;
 	}
 	on(e, t) {
 		let n = t;
@@ -632,35 +800,38 @@ var d = e({}), f = e(void 0), p = "x-ably-status", m = "x-ably-turn-id", h = "x-
 		};
 	}
 	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?.();
+		if (!this._closed) {
+			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._regenSelections.clear(), this._withheldRunIds.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);
+		let t = e * fe, n = await H(this._channel, { limit: t }, this._logger);
+		this._closed || await this._revealFromPage(n, e);
+	}
+	async _revealFromPage(e, t) {
+		let n = new Set(this._treeVisibleNodes().map((e) => N(e))), { newVisible: r, lastPage: i } = await this._loadUntilVisible(e, t, n);
+		this._closed || (this._lastHistoryPage = i, this._hasMoreHistory = i.hasNext(), this._splitReveal(r, t));
+	}
+	_splitReveal(e, t) {
+		let n = 0, r = e.length;
+		for (let i = e.length - 1; i >= 0; i--) {
+			if (e[i]?.kind === "run") {
+				if (n === t) break;
+				n++;
+			}
+			r = i;
+		}
+		let i = e.slice(r), a = e.slice(0, r);
+		for (let e of a) this._withheldRunIds.add(N(e));
+		this._withheldBuffer.push(...a), this._releaseWithheld(i);
 	}
 	_processHistoryPage(e) {
 		this._processingHistory = !0;
 		try {
-			for (let t of e.items) {
-				let e = t.headers[h];
-				e && this._tree.upsert(e, t.message, t.headers, t.serial);
-			}
+			let t = this._codec.createDecoder();
+			for (let n of e.rawMessages) M(this._tree, t, n);
 			for (let t of e.rawMessages) this._tree.emitAblyMessage(t);
 		} finally {
 			this._processingHistory = !1;
@@ -670,7 +841,7 @@ var d = e({}), f = e(void 0), p = "x-ably-status", m = "x-ably-turn-id", h = "x-
 		this._processHistoryPage(e);
 		let r = e, i = () => {
 			let e = 0;
-			for (let t of this._tree.flattenNodes(this._resolveSelections())) n.has(t.msgId) || e++;
+			for (let t of this._treeVisibleNodes()) t.kind === "run" && !n.has(N(t)) && e++;
 			return e;
 		};
 		for (; i() < t && r.hasNext();) {
@@ -679,678 +850,493 @@ var d = e({}), f = e(void 0), p = "x-ably-status", m = "x-ably-turn-id", h = "x-
 			this._processHistoryPage(e), r = e;
 		}
 		return {
-			newVisible: this._tree.flattenNodes(this._resolveSelections()).filter((e) => !n.has(e.msgId)),
+			newVisible: this._treeVisibleNodes().filter((e) => !n.has(N(e))),
 			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"));
+		for (let t of e) this._withheldRunIds.delete(N(t));
+		e.length > 0 && this._recomputeAndEmit();
 	}
 	_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);
-		}
+		let t = e ?? this._cachedNodes;
+		this._lastVisibleNodeKeys = t.map((e) => N(e)), this._lastVisibleNodeKeySet = new Set(this._lastVisibleNodeKeys), this._lastVisibleProjections = t.map((e) => e.projection), this._lastVisibleMessagePairs = this._extractMessages(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"));
+		this._processingHistory || (this._pinBranchSelections(), this._resolvePendingRegenSelections(), this._recomputeAndEmitIfChanged());
 	}
 	_resolveSelections() {
 		let e = /* @__PURE__ */ new Map();
-		for (let [t, n] of this._branchSelections) n.kind !== "pending" && e.set(t, n.selectedId);
+		for (let [t, n] of this._branchSelections) e.set(t, n.selectedKey);
+		for (let [t, n] of this._regenSelections) n.kind !== "pending" && e.set(t, n.selectedRunId);
 		return e;
 	}
+	_treeVisibleNodes() {
+		return this._tree.visibleNodes(this._resolveSelections());
+	}
 	_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, {
+		for (let e of this._lastVisibleNodeKeys) {
+			if (this._tree.getNode(e)?.kind !== "input" || this._tree.getSiblingNodes(e).length <= 1) continue;
+			let t = this._tree.getGroupRoot(e);
+			this._branchSelections.get(t) || this._branchSelections.set(t, {
 				kind: "pinned",
-				selectedId: e
+				selectedKey: e
 			});
 		}
 	}
-	_resolvePendingSelections() {
-		for (let [e, t] of this._branchSelections) {
-			if (t.kind !== "pending") continue;
-			let n = this._tree.getSiblingNodes(e);
+	_resolvePendingRegenSelections() {
+		for (let [e, t] of this._regenSelections) {
+			if (t.kind === "user") continue;
+			let n = this._tree.getSiblingNodes(e).filter((e) => e.kind === "run");
 			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, {
+			r && this._regenSelections.set(e, {
 				kind: "auto",
-				selectedId: r.msgId
-			}));
+				selectedRunId: r.runId
+			});
 		}
 	}
 	_onTreeAblyMessage(e) {
-		let t = P(e)[h];
-		if (!t) {
+		let t = D(e), n = t[m], r = t[d];
+		if (!n && !r) {
 			this._emitter.emit("ably-message", e);
 			return;
 		}
-		this._lastVisibleIds.includes(t) && this._emitter.emit("ably-message", e);
+		r && this._lastVisibleNodeKeySet.has(r) && this._emitter.emit("ably-message", e);
 	}
-	_onTreeTurn(e) {
-		if (this._lastVisibleTurnIds.has(e.turnId)) {
-			this._emitter.emit("turn", e);
+	_onTreeRun(e) {
+		if (this._lastVisibleNodeKeySet.has(e.runId)) {
+			this._emitter.emit("run", e);
 			return;
 		}
-		e.type === "x-ably-turn-start" && this._isTurnStartVisible(e) && (this._lastVisibleTurnIds.add(e.turnId), this._emitter.emit("turn", e));
+		e.type === "start" && this._isRunStartVisible(e) && (this._lastVisibleNodeKeySet.add(e.runId), this._emitter.emit("run", e));
 	}
-	_isTurnStartVisible(e) {
+	_isRunStartVisible(e) {
 		let { parent: t } = e;
-		return t === void 0 ? !0 : this._lastVisibleIds.includes(t);
+		if (t === void 0) return !0;
+		let n = this._tree.getNodeByCodecMessageId(t);
+		return n ? this._lastVisibleNodeKeySet.has(N(n)) : !0;
 	}
-	_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;
+	_visibleChanged(e) {
+		if (e.length !== this._lastVisibleNodeKeys.length) return !0;
+		for (let [t, n] of e.entries()) if (N(n) !== this._lastVisibleNodeKeys[t] || n.projection !== this._lastVisibleProjections[t]) 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 {
+}, W = (e) => new pe(e), me = () => {}, he = class {
 	constructor(e) {
-		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({
+		this._views = /* @__PURE__ */ new Set(), this._state = "ready", this._pendingRunStarts = /* @__PURE__ */ new Map();
+		let t = ce(e.client, e.codec);
+		if (this._channel = e.client.channels.get(e.channelName, t), this._codec = e.codec, this._clientId = e.clientId, this._logger = (e.logger ?? ie({ logLevel: T.Silent })).withContext({ component: "ClientSession" }), this._emitter = new w(this._logger), this._hasAttachedOnce = this._channel.state === "attached", this._tree = R(this._codec, 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) {
+		}), this._decoder = this._codec.createDecoder(), this._encoder = this._codec.createEncoder(this._channel, this._clientId === void 0 ? void 0 : { clientId: this._clientId }), 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 = crypto.randomUUID(), r = { [h]: e };
-				t && (r[C] = t), this._tree.upsert(e, n, r), t = e;
+				let e = crypto.randomUUID(), r = {
+					[m]: e,
+					[_]: "user"
+				};
+				t && (r[v] = t), this._tree.applyMessage({
+					inputs: [this._codec.createUserMessage(n)],
+					outputs: []
+				}, r), t = e;
 			}
 		}
 		this._onMessage = (e) => {
 			this._handleMessage(e);
-		}, this._attachPromise = this._channel.subscribe(this._onMessage), this._onChannelStateChange = (e) => {
+		}, this._onChannelStateChange = (e) => {
 			this._handleChannelStateChange(e);
 		}, this._channel.on(this._onChannelStateChange);
 	}
-	_handleMessage(e) {
-		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,
-						...e !== void 0 && { parent: e },
-						...i !== void 0 && { forkOf: i }
-					});
+	connect() {
+		return this._state === "closed" ? Promise.reject(new e.ErrorInfo("unable to connect; session is closed", C.SessionClosed, 400)) : this._connectPromise ? this._connectPromise : (this._logger.trace("DefaultClientSession.connect();"), this._connectPromise = this._channel.subscribe(this._onMessage).then(() => {
+			this._logger.debug("DefaultClientSession.connect(); subscribed and attached");
+		}, (t) => {
+			let n = new e.ErrorInfo(`unable to subscribe to channel; ${t instanceof Error ? t.message : String(t)}`, C.SessionSubscriptionError, 500, t instanceof e.ErrorInfo ? t : void 0);
+			throw this._logger.error("DefaultClientSession.connect(); subscribe failed"), this._emitter.emit("error", n), n;
+		}), this._connectPromise);
+	}
+	async _requireConnected(t) {
+		if (!this._connectPromise) throw new e.ErrorInfo(`unable to ${t}; connect() must be called before ${t}()`, C.InvalidArgument, 400);
+		return this._connectPromise;
+	}
+	_handleMessage(t) {
+		if (this._state !== "closed") try {
+			if (t.name === "ai-run-end") {
+				let n = D(t);
+				if ((n["run-reason"] ?? "complete") === "error") {
+					let t = n[S], r = t === void 0 ? NaN : Number(t), i = Number.isFinite(r) ? r : C.SessionSubscriptionError, a = n["error-message"] ?? "agent reported an error", o = i >= 1e4 && i < 6e4 ? Math.floor(i / 100) : 500, s = new e.ErrorInfo(a, i, o);
+					this._logger.error("ClientSession._handleMessage(); agent error received", {
+						runId: n[d],
+						invocationId: n[f],
+						code: i
+					}), this._emitter.emit("error", s);
 				}
-				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);
-					}
-					this._ownTurnIds.delete(n), this._tree.emitTurn({
-						type: D,
-						turnId: n,
-						clientId: r,
-						reason: i
-					});
+			let n = M(this._tree, this._decoder, t);
+			if (n && (n.type === "start" || n.type === "resume")) {
+				let e = D(t)[x];
+				if (e !== void 0) {
+					let t = this._pendingRunStarts.get(e);
+					t && (this._pendingRunStarts.delete(e), t.resolve(n.runId));
 				}
-				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));
+			this._tree.emitAblyMessage(t);
+		} catch (t) {
+			let n = t instanceof e.ErrorInfo ? t : void 0;
+			this._emitter.emit("error", new e.ErrorInfo(`unable to process channel message; ${t instanceof Error ? t.message : String(t)}`, C.SessionSubscriptionError, 500, n));
 		}
 	}
-	_handleMessageOutput(e, t, n, r) {
-		let i = t[h];
-		if (i && this._ownMsgIds.has(i)) {
-			this._upsertAndNotify(e, t, n);
-			return;
-		}
-		r === "message.create" && this._upsertAndNotify(e, t, n);
-	}
-	_handleEventOutput(e, t) {
-		if (e.kind !== "event") return;
-		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);
-				return;
-			}
-			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) {
+	_handleChannelStateChange(t) {
+		if (this._state === "closed") return;
+		let { current: n, resumed: r } = t;
+		if (n === "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 = t[h];
-		r && this._tree.upsert(r, e, t, n);
-	}
-	_updateTurnObserverHeaders(e, t, n) {
-		let r = this._turnObservers.get(e);
-		r ? (Object.keys(t).length > 0 && Object.assign(r.headers, t), n !== void 0 && (r.serial = n)) : this._turnObservers.set(e, {
-			headers: { ...t },
-			serial: n,
-			accumulator: this._codec.createAccumulator()
-		});
-	}
-	_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 i = n.accumulator.messages;
-		if (i.length === 0) return;
-		let a;
-		try {
-			a = structuredClone(i.at(-1));
-		} catch {
-			a = i.at(-1);
-		}
-		if (a) {
-			let e = n.headers[h];
-			e && this._tree.upsert(e, a, { ...n.headers }, n.serial);
-		}
-	}
-	async _publishCancel(e) {
-		this._logger.trace("ClientTransport._publishCancel();", { filter: e });
-		let t = {};
-		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 }
+		if (!(n === "failed" || n === "suspended" || n === "detached" || n === "attached" && !r)) return;
+		this._logger.error("ClientSession._handleChannelStateChange(); channel continuity lost", {
+			current: n,
+			resumed: r,
+			previous: t.previous
 		});
+		let i = new e.ErrorInfo(`unable to deliver events; channel continuity lost (${n}${n === "attached" ? ", resumed: false" : ""})`, C.ChannelContinuityLost, 500, t.reason);
+		this._emitter.emit("error", i);
 	}
-	_closeMatchingTurnStreams(e) {
-		for (let t of this._getMatchingTurnIds(e)) this._router.closeStream(t);
-	}
-	_getMatchingTurnIds(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;
-			}
+	_cleanupFailedSend(e) {
+		for (let t of e) {
+			let e = this._tree.getNodeByCodecMessageId(t);
+			e?.kind === "input" && e.serial === void 0 && this._tree.delete(e.codecMessageId);
 		}
-		return t;
 	}
 	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({
+		if (this._state === "closed") throw new e.ErrorInfo("unable to create view; session is closed", C.SessionClosed, 400);
+		this._logger.trace("DefaultClientSession.createView();");
+		let t = W({
 			tree: this._tree,
 			channel: this._channel,
 			codec: this._codec,
 			sendDelegate: this._internalSend.bind(this),
 			logger: this._logger,
-			onClose: () => this._views.delete(e)
+			onClose: () => this._views.delete(t)
 		});
-		return this._views.add(e), e;
+		return this._views.add(t), t;
 	}
-	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);
+	async _internalSend(t, n, r) {
+		if (this._state === "closed" || (await this._requireConnected("send"), this._state === "closed")) throw new e.ErrorInfo("unable to send; session is closed", C.SessionClosed, 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 = f.at(-1);
-			e && (p = e.msgId);
-		}
-		let m = t?.parent === void 0 ? p : t.parent;
-		for (let e of a) {
-			let n = crypto.randomUUID();
-			this._ownMsgIds.add(n), u.add(n);
-			let r = t?.parent === void 0 ? p : t.parent, i = F({
+		if (i !== "attached" && i !== "attaching") throw new e.ErrorInfo(`unable to send; channel is ${i}`, C.ChannelNotReady, 400);
+		this._logger.trace("ClientSession._internalSend();");
+		let a = n?.runId !== void 0, o = n?.runId, s;
+		n?.parent === void 0 && !n?.forkOf && (s = r);
+		let c = /* @__PURE__ */ new Set(), l = [];
+		for (let e of t) {
+			let t = crypto.randomUUID(), r = e.codecMessageId ?? crypto.randomUUID();
+			c.add(r);
+			let i = e.kind !== "user-message" && (e.kind === "regenerate" || e.codecMessageId !== void 0), a = e.parent ?? (n?.parent === void 0 ? s : n.parent), u = n?.forkOf, d = e.kind === "regenerate" ? e.target : void 0, f = le({
 				role: "user",
-				turnId: o,
-				msgId: n,
-				turnClientId: this._clientId,
-				parent: r,
-				forkOf: t?.forkOf
+				runId: o,
+				codecMessageId: r,
+				runClientId: this._clientId,
+				...a !== void 0 && { parent: a },
+				...u !== void 0 && { forkOf: u },
+				...d !== void 0 && { regenerates: d },
+				inputEventId: t
 			});
-			this._upsertAndNotify(e, i), d.push({
-				kind: "message",
-				message: e,
-				msgId: n,
-				parentId: r,
-				forkOf: t?.forkOf,
-				headers: i,
-				serial: void 0
-			}), t?.parent === void 0 && !t?.forkOf && (p = n);
+			i || this._tree.applyMessage({
+				inputs: [e],
+				outputs: []
+			}, f), l.push({
+				input: e,
+				codecMessageId: r,
+				inputEventId: t,
+				headers: f,
+				isWireOnly: i
+			}), !i && n?.parent === void 0 && !n?.forkOf && e.parent === void 0 && (s = r);
 		}
-		this._turnMsgIds.set(o, u);
-		let h = this._router.createStream(o), g = this._headersFn?.() ?? {}, _ = {
-			...this._bodyFn?.() ?? {},
-			history: f,
-			...t?.body,
-			turnId: o,
-			clientId: this._clientId,
-			messages: d,
-			...t?.forkOf !== void 0 && { forkOf: t.forkOf },
-			...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",
-				...v
-			},
-			body: JSON.stringify(_),
-			...this._credentials ? { credentials: this._credentials } : {}
-		}).then((e) => {
-			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);
+		let u = l.at(-1);
+		if (u === void 0) throw new e.ErrorInfo("unable to send; inputs array is empty (include at least one input)", C.InvalidArgument, 400);
+		let d = u.inputEventId, f = u.codecMessageId, p = new Promise((e, t) => {
+			this._pendingRunStarts.set(f, {
+				resolve: e,
+				reject: t
+			});
+		});
+		return p.catch(() => {}), await (async () => {
+			try {
+				for (let e of l) await this._encoder.publishInput(e.input, {
+					extras: { headers: e.headers },
+					messageId: e.codecMessageId,
+					...this._clientId !== void 0 && { clientId: this._clientId }
+				});
+			} catch (t) {
+				let n = t instanceof e.ErrorInfo ? t : void 0, r = n?.statusCode === 401 || n?.statusCode === 403, i = new e.ErrorInfo(r ? "unable to publish events; missing publish capability on the channel" : `unable to publish events; ${t instanceof Error ? t.message : String(t)}`, r ? C.InsufficientCapability : C.SessionSendFailed, r ? 401 : 500, n);
+				throw this._emitter.emit("error", i), this._pendingRunStarts.delete(f), a || this._cleanupFailedSend([...c]), i;
 			}
-		}).catch((e) => {
-			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: h,
-			turnId: o,
-			cancel: async () => this.cancel({ turnId: o }),
-			optimisticMsgIds: [...u]
+		})(), {
+			inputCodecMessageId: f,
+			runId: p,
+			inputEventId: d,
+			cancel: async () => {
+				await this._publishCancel({
+					inputCodecMessageId: f,
+					...o !== void 0 && { runId: o }
+				});
+			},
+			optimisticCodecMessageIds: [...c],
+			toInvocation: () => ue.fromJSON({
+				inputEventId: d,
+				sessionName: this._channel.name
+			})
 		};
 	}
 	async cancel(e) {
-		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);
-		}
+		return this._publishCancel({ runId: e });
 	}
-	async waitForTurn(e) {
-		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 = !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);
+	async _publishCancel(e) {
+		if (this._state === "closed" || (await this._requireConnected("cancel"), this._state === "closed")) return;
+		this._logger.debug("ClientSession._publishCancel();", {
+			runId: e.runId,
+			inputCodecMessageId: e.inputCodecMessageId
+		});
+		let t = { [p]: crypto.randomUUID() };
+		e.runId !== void 0 && (t[d] = e.runId), e.inputCodecMessageId !== void 0 && (t[x] = e.inputCodecMessageId), await this._channel.publish({
+			name: ee,
+			extras: { ai: { transport: t } }
 		});
 	}
 	on(e, t) {
-		if (this._state === G.CLOSED) return se;
+		if (this._state === "closed") return me;
 		let n = t;
 		return this._emitter.on(e, n), () => {
 			this._emitter.off(e, n);
 		};
 	}
-	async close(e) {
-		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.off(this._onChannelStateChange);
-			for (let e of this._ownTurnIds) this._router.closeStream(e);
-			this._turnObservers.clear(), this._emitter.off();
+	async close() {
+		if (this._state !== "closed") {
+			this._state = "closed", this._logger.info("ClientSession.close();"), this._connectPromise && this._channel.unsubscribe(this._onMessage), this._channel.off(this._onChannelStateChange), 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();
+			if (this._views.clear(), this._pendingRunStarts.size > 0) {
+				let t = new e.ErrorInfo("unable to await run-start; session closed", C.SessionClosed, 400);
+				for (let e of this._pendingRunStarts.values()) e.reject(t);
+				this._pendingRunStarts.clear();
+			}
+			try {
+				await this._encoder.close();
+			} catch {}
+			if (this._connectPromise) try {
+				await this._channel.detach();
+			} catch (e) {
+				this._logger.debug("ClientSession.close(); channel detach failed", { error: e });
+			}
 		}
 	}
-}, 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);
+}, ge = (e) => new he(e), G = n({
+	nearest: void 0,
+	providers: {}
+}), K = ({ children: n, ...r }) => {
+	let c = t(), { channelName: u } = r, d = s(void 0), f = s(u), p = s([]), m = s(!1), h = s(void 0);
+	if (!(d.current || h.current) || f.current !== u) {
+		f.current = u, d.current && p.current.push(d.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);
+			d.current = ge({
+				...r,
+				client: c
+			}), h.current = void 0;
+		} catch (t) {
+			d.current = void 0, h.current = t instanceof e.ErrorInfo ? t : new e.ErrorInfo("Unknown error while creating client session", C.BadRequest, 400);
 		}
 	}
-	let v = n(d), y = p.current, b = _.current, x = i(() => ({
-		transport: y,
-		error: b
-	}), [y, b]), S = i(() => ({
-		...v,
-		[e]: x
+	let g = i(G), _ = d.current, v = h.current, y = o(() => ({
+		session: _,
+		sessionError: v
+	}), [_, v]), b = o(() => ({
+		nearest: y,
+		providers: {
+			...g.providers,
+			[u]: y
+		}
 	}), [
-		e,
-		v,
-		x
+		u,
+		g,
+		y
 	]);
-	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();
+	return a(() => () => {
+		for (let e of p.current) e.close();
+	}, [u]), a(() => {
+		d.current?.connect();
+	}, [u]), a(() => (m.current = !1, () => {
+		m.current = !0, Promise.resolve().then(() => {
+			m.current && d.current?.close();
 		});
-	}), []), /* @__PURE__ */ u(d.Provider, {
-		value: S,
-		children: /* @__PURE__ */ u(f.Provider, {
-			value: x,
-			children: t
-		})
+	}), []), /* @__PURE__ */ l(G.Provider, {
+		value: b,
+		children: n
 	});
-}, 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;
-			});
+}, q = ({ session: e, skip: t } = {}) => {
+	let { nearest: n } = i(G), r = n?.session;
+	if (!t && e !== null) return e ?? r;
+}, J = ({ session: e, skip: t } = {}) => {
+	let n = q({
+		session: e,
+		skip: t
+	}), [r, i] = c([]), o = s([]);
+	return a(() => {
+		if (o.current = [], i([]), n) return n.tree.on("ably-message", (e) => {
+			let t = [...o.current, e];
+			o.current = t, i(t);
 		});
-	}, [i]), a;
+	}, [n]), r;
 }, Y = {
 	get tree() {
-		throw new s.ErrorInfo("unable to access tree; hook is skipped", O.InvalidArgument, 400);
+		throw new e.ErrorInfo("unable to access tree; hook is skipped", C.InvalidArgument, 400);
 	},
 	get view() {
-		throw new s.ErrorInfo("unable to access view; hook is skipped", O.InvalidArgument, 400);
+		throw new e.ErrorInfo("unable to access view; hook is skipped", C.InvalidArgument, 400);
+	},
+	connect: () => {
+		throw new e.ErrorInfo("unable to connect; hook is skipped", C.InvalidArgument, 400);
 	},
 	createView: () => {
-		throw new s.ErrorInfo("unable to create view; hook is skipped", O.InvalidArgument, 400);
+		throw new e.ErrorInfo("unable to create view; hook is skipped", C.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);
+		throw new e.ErrorInfo("unable to cancel; hook is skipped", C.InvalidArgument, 400);
 	},
 	on: () => {
-		throw new s.ErrorInfo("unable to subscribe; hook is skipped", O.InvalidArgument, 400);
+		throw new e.ErrorInfo("unable to subscribe; hook is skipped", C.InvalidArgument, 400);
 	},
 	close: () => {
-		throw new s.ErrorInfo("unable to close; hook is skipped", O.InvalidArgument, 400);
+		throw new e.ErrorInfo("unable to close; hook is skipped", C.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(() => {
+}, X = ({ channelName: t, skip: n, onError: r } = {}) => {
+	let { nearest: o, providers: c } = i(G), l = s(r);
+	l.current = r;
+	let u = n ? void 0 : t === void 0 ? o?.session : c[t]?.session;
+	if (a(() => {
 		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
+	}, [u]), n) return { session: Y };
+	if (t !== void 0) {
+		let n = c[t];
+		return n ? n.session ? { session: n.session } : {
+			session: Y,
+			sessionError: n.sessionError
 		} : {
-			transport: Y,
-			transportError: new s.ErrorInfo(`unable to use transport; no TransportProvider found for channelName "${e}"`, O.BadRequest, 400)
+			session: Y,
+			sessionError: new e.ErrorInfo(`unable to use session; no ClientSessionProvider found for channelName "${t}"`, C.BadRequest, 400)
 		};
 	}
-	return c ? c.transport ? { transport: c.transport } : {
-		transport: Y,
-		transportError: c.error
+	return o ? o.session ? { session: o.session } : {
+		session: Y,
+		sessionError: o.sessionError
 	} : {
-		transport: Y,
-		transportError: new s.ErrorInfo("unable to use transport; no TransportProvider found in the tree", O.BadRequest, 400)
+		session: Y,
+		sessionError: new e.ErrorInfo("unable to use session; no ClientSessionProvider found in the tree", C.BadRequest, 400)
 	};
-}, 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);
+}, _e = {
+	hasSiblings: !1,
+	siblings: [],
+	index: 0,
+	selected: void 0
+}, Z = ({ session: t, view: n, limit: i, skip: o } = {}) => {
+	let l = q({
+		session: t,
+		skip: o
+	}), u = o ? void 0 : n ?? l?.view, [d, f] = c(() => u?.getMessages() ?? []), [p, m] = c(() => u?.hasOlder() ?? !1), [h, g] = c(!1), [_, v] = c(), y = s(!1), b = i !== void 0, x = s(!1);
+	a(() => {
+		if (!u) {
+			f([]), m(!1), v(void 0);
 			return;
 		}
-		return T.current = !1, g(m.flattenNodes()), v(m.hasOlder()), S(void 0), m.on("update", () => {
-			g(m.flattenNodes()), v(m.hasOlder());
+		return x.current = !1, f(u.getMessages()), m(u.hasOlder()), v(void 0), u.on("update", () => {
+			f(u.getMessages()), m(u.hasOlder());
 		});
-	}, [m]);
-	let E = t(async () => {
-		if (!(!m || C.current)) {
-			C.current = !0, b(!0);
+	}, [u]);
+	let S = r(async () => {
+		if (!(!u || y.current)) {
+			y.current = !0, g(!0);
 			try {
-				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));
+				await u.loadOlder(i), v(void 0);
+			} catch (t) {
+				t instanceof e.ErrorInfo ? v(t) : v(new e.ErrorInfo("Unknown error loading older messages", C.BadRequest, 400));
 			} finally {
-				C.current = !1, b(!1);
+				y.current = !1, g(!1);
 			}
 		}
-	}, [m, l]);
-	return r(() => {
-		!w || T.current || !m || (T.current = !0, E());
+	}, [u, i]);
+	return a(() => {
+		!b || x.current || !u || (x.current = !0, S());
 	}, [
-		w,
-		m,
-		E
+		b,
+		u,
+		S
 	]), {
-		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])
+		messages: d,
+		hasOlder: p,
+		loading: h,
+		loadError: _,
+		loadOlder: S,
+		runOf: r((e) => u?.runOf(e), [u]),
+		run: r((e) => u?.run(e), [u]),
+		runs: r(() => u?.runs() ?? [], [u]),
+		branchSelection: r((e) => u?.branchSelection(e) ?? _e, [u]),
+		selectSibling: r((e, t) => {
+			u?.selectSibling(e, t);
+		}, [u]),
+		send: r(async (t, n) => {
+			if (!u) throw new e.ErrorInfo("unable to send; view is not available", C.InvalidArgument, 400);
+			return u.send(t, n);
+		}, [u]),
+		regenerate: r(async (t, n) => {
+			if (!u) throw new e.ErrorInfo("unable to regenerate; view is not available", C.InvalidArgument, 400);
+			return u.regenerate(t, n);
+		}, [u]),
+		edit: r(async (t, n, r) => {
+			if (!u) throw new e.ErrorInfo("unable to edit; view is not available", C.InvalidArgument, 400);
+			return u.edit(t, n, r);
+		}, [u])
 	};
-}, 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);
+}, Q = ({ session: e, limit: t, skip: n } = {}) => {
+	let r = q({
+		session: e,
+		skip: n
+	}), [i, o] = c();
+	return a(() => {
+		if (!r) {
+			o(void 0);
 			return;
 		}
-		let e = s.createView();
-		return l(e), () => {
+		let e = r.createView();
+		return o(e), () => {
 			e.close();
 		};
-	}, [s]), Z({
-		view: c,
+	}, [r]), Z({
+		view: i,
 		limit: t,
-		skip: i
+		skip: n
 	});
-}, $ = ({ transport: e } = {}) => {
-	let r = n(f), i = e ?? r?.transport;
+}, $ = ({ session: e } = {}) => {
+	let t = q({ session: e });
 	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])
+		getRunNode: r((e) => t?.tree.getRunNode(e), [t]),
+		getNodeByCodecMessageId: r((e) => t?.tree.getNodeByCodecMessageId(e), [t]),
+		getSiblingNodes: r((e) => t?.tree.getSiblingNodes(e) ?? [], [t])
 	};
-}, de = () => ({
-	TransportProvider: K,
-	useClientTransport: (e) => X(e ?? {}),
+}, ve = () => ({
+	ClientSessionProvider: K,
+	useClientSession: (e) => X(e ?? {}),
 	useView: (e) => Z(e ?? {}),
-	useActiveTurns: (e) => J(e ?? {}),
 	useTree: (e) => $(e ?? {}),
-	useAblyMessages: (e) => q(e ?? {}),
+	useAblyMessages: (e) => J(e ?? {}),
 	useCreateView: (e) => Q(e ?? {})
 });
 //#endregion
-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 };
+export { K as ClientSessionProvider, ve as createSessionHooks, J as useAblyMessages, X as useClientSession, Q as useCreateView, $ as useTree, Z as useView };
 
 //# sourceMappingURL=ably-ai-transport-react.js.map