statewire 0.23.0 → 0.24.1

package/dist/client/session.js

@@ -43,10 +43,11 @@ const laneEntries = (s, protocol) => s.pending.filter((p) => isStamped(p) && p.c
 const sortPending = (s) => {
 	s.pending.sort((a, b) => (a.seq ?? Infinity) - (b.seq ?? Infinity) || 0);
 };
-const marks = (s, lane, removed) => {
+const marks = (s, lane, removed, failure) => {
 	const added = removed.filter((c) => c.by !== void 0 && c.by !== s.store.owner?.id).map((c) => ({
 		id: c.id,
-		by: c.by
+		by: c.by,
+		...failure && { failure }
 	}));
 	const next = [...lane.removed ?? [], ...added];
 	return next.length > 0 ? { removed: next } : {};
@@ -59,12 +60,11 @@ const withOutbox = (lane, outbox) => {
 	} : rest;
 };
 const outboxOf = (lane) => lane.outbox ?? [];
-const sameHold = (a, b) => a === b || JSON.stringify(a) === JSON.stringify(b);
 const changed = (s, p) => s.lifecycle?.onChange?.(p.inv);
 const stamp = (s, p, seq) => {
 	p.seq = seq;
 	p.inv.seq = seq;
-	delete p.inv.hold;
+	delete p.inv.held;
 	p.away = false;
 	p.attempted = false;
 	p.posted = false;
@@ -78,12 +78,31 @@ const unstamp = (s, p) => {
 	p.posted = false;
 	changed(s, p);
 };
-const setHold = (s, p, hold) => {
-	if (sameHold(p.inv.hold, hold)) return;
-	if (hold === void 0) delete p.inv.hold;
-	else p.inv.hold = hold;
-	changed(s, p);
+const follow = (s, p, stored) => {
+	let dirty = false;
+	if (p.inv.held === true !== (stored.held === true)) {
+		if (stored.held) p.inv.held = true;
+		else delete p.inv.held;
+		dirty = true;
+	}
+	if (p.inv.localMeta !== stored.localMeta) {
+		if (stored.localMeta === void 0) delete p.inv.localMeta;
+		else p.inv.localMeta = stored.localMeta;
+		dirty = true;
+	}
+	if (p.command.params !== stored.params) {
+		p.command = {
+			...p.command,
+			params: stored.params,
+			...stored.meta === void 0 ? {} : { meta: stored.meta }
+		};
+		if (stored.meta === void 0) delete p.command.meta;
+		p.inv.params = paramsOf(stored);
+		dirty = true;
+	}
+	if (dirty) changed(s, p);
 };
+const paramsOf = (stored) => stored.meta === void 0 ? stored.params : reviveDocumentValue(structuredClone(stored.params), stored.meta);
 const dropPending = (s, p) => {
 	s.pending = s.pending.filter((q) => q !== p);
 	s.lifecycle?.onCovered?.(p.inv);
@@ -120,10 +139,12 @@ const setRecord = (s, record) => {
 	if (!s.deactivated) try {
 		s.store.save(record);
 	} catch (cause) {
+		if (isQuota(cause)) throw cause;
 		storageFailed(s, cause);
 		throw s.storageError;
 	}
 	s.record = record;
+	s.notify();
 };
 const toOutbox = (p) => {
 	const { protocol: _protocol, ...command } = p.command;
@@ -132,7 +153,8 @@ const toOutbox = (p) => {
 		...command,
 		ts: p.inv.ts,
 		...p.by !== void 0 && { by: p.by },
-		...p.inv.hold !== void 0 && { hold: p.inv.hold }
+		...p.inv.held && { held: true },
+		...p.inv.localMeta !== void 0 && { localMeta: p.inv.localMeta }
 	};
 };
 const toStored = (s, p) => {
@@ -143,7 +165,8 @@ const toStored = (s, p) => {
 		...s.store.owner !== void 0 && { owner: s.store.owner.id },
 		...p.by !== void 0 && { by: p.by },
 		...command,
-		ts: p.inv.ts
+		ts: p.inv.ts,
+		...p.inv.localMeta !== void 0 && { localMeta: p.inv.localMeta }
 	};
 };
 const backlog = (s, protocol) => laneEntries(s, protocol).map((p) => toStored(s, p));
@@ -154,20 +177,25 @@ const mergeBacklog = (s, protocol) => {
 };
 const durableLanes = (s) => [.../* @__PURE__ */ new Set([...Object.keys(s.record.lanes), ...s.pending.map((p) => p.command.protocol).filter((protocol) => !isEphemeral(s, protocol))])];
 const syncBacklogInner = (s) => {
+	if (s.shared && s.shared.notices.length > 0) noticeInner(s, s.shared.notices.splice(0));
 	const parked = s.shared ? s.shared.parked.splice(0) : [];
+	const settled = s.shared ? new Set(s.shared.settled) : /* @__PURE__ */ new Set();
+	if (s.shared) s.shared.settled.clear();
 	let lanes = s.record.lanes;
 	for (const protocol of durableLanes(s)) {
 		const lane = laneOf(s.record, protocol);
-		const parkedHere = parked.filter((v) => v.protocol === protocol).map(({ verdict }) => {
+		const parkedHere = parked.filter((v) => v.protocol === protocol).flatMap(({ verdict }) => {
 			const id = verdict.id ?? lane.commands.find((c) => c.seq === verdict.seq)?.id;
-			return id === void 0 ? verdict : {
+			if (id === void 0 || settled.has(id)) return [];
+			return [{
 				...verdict,
 				id
-			};
+			}];
 		});
 		const parkedSeqs = new Set(parkedHere.map((v) => v.seq));
 		const commands = mergeBacklog(s, protocol).filter((c) => !parkedSeqs.has(c.seq));
-		const verdicts = parkedHere.length > 0 ? [...lane.verdicts ?? [], ...parkedHere].slice(-64) : lane.verdicts;
+		const kept = (lane.verdicts ?? []).filter((v) => v.id === void 0 || !settled.has(v.id));
+		const verdicts = parkedHere.length > 0 || kept.length !== (lane.verdicts ?? []).length ? [...kept, ...parkedHere].slice(-64) : lane.verdicts;
 		if (verdicts === lane.verdicts && commands.length === lane.commands.length && commands.every((c, i) => c.seq === lane.commands[i].seq)) continue;
 		lanes = {
 			...lanes,
@@ -202,8 +230,14 @@ const transact = (s, fn) => {
 	}
 	const shared = s.shared;
 	const result = shared.txq.then(() => s.store.lock(async () => {
-		refresh(s);
-		fn();
+		const stored = await readStored(s);
+		shared.inTx = true;
+		try {
+			refresh(s, stored);
+			fn();
+		} finally {
+			shared.inTx = false;
+		}
 		watchOwners(s);
 		s.notify();
 		const persistence = s.store.flush?.();
@@ -215,14 +249,15 @@ const transact = (s, fn) => {
 	shared.txq = result.then(() => {}, () => {});
 	return result;
 };
-const refresh = (s) => {
-	const stored = s.store.load();
+const readStored = async (s) => s.store.read ? await s.store.read() : s.store.load();
+const refresh = (s, stored) => {
 	if (stored !== null && stored.clientId !== s.record.clientId) {
 		adoptReset(s, stored);
 		return;
 	}
-	if (stored !== null) s.record = boundRecord(stored);
+	if (stored !== null) s.record = boundInbox(s.store, stored);
 	reconcileLocal(s);
+	followReleases(s);
 };
 const reconcileLocal = (s) => {
 	const me = s.store.owner?.id;
@@ -240,7 +275,7 @@ const reconcileLocal = (s) => {
 				}
 				unstamp(s, p);
 			}
-			setHold(s, p, queued.hold);
+			follow(s, p, queued);
 		} else if (stamped && stamped.owner !== me) {
 			if (p.adopted) dropPending(s, p);
 			else if (!p.away) {
@@ -249,12 +284,20 @@ const reconcileLocal = (s) => {
 			}
 		} else if (stamped) {
 			if (p.seq !== stamped.seq) stamp(s, p, stamped.seq);
-		} else if (isOutboxed(p)) {
-			if (!lane.removed?.some((m) => m.id === p.id)) {
+		} else if (!p.adopted && (isOutboxed(p) || p.away)) {
+			const mark = lane.removed?.find((m) => m.id === p.id);
+			if (mark === void 0) {
 				p.away = true;
 				continue;
 			}
-			settleRemoved(s, p);
+			s.lifecycle?.onCovered?.(p.inv);
+			settleEntry(s, p, {
+				ok: false,
+				failure: mark.failure ?? {
+					fate: "aborted",
+					cause: "removed"
+				}
+			}, mark.failure ? "noticed" : "memory");
 			const { removed: _removed, ...rest } = lane;
 			const left = lane.removed.filter((m) => m.id !== p.id);
 			setRecord(s, withLane(s.record, protocol, {
@@ -264,6 +307,48 @@ const reconcileLocal = (s) => {
 		}
 	}
 };
+const locate = (s, id) => {
+	for (const [protocol, lane] of Object.entries(s.record.lanes)) {
+		const stored = outboxOf(lane).find((c) => c.id === id);
+		if (stored) return {
+			protocol,
+			stored
+		};
+		if (lane.commands.some((c) => c.id === id)) return { protocol };
+	}
+	const p = s.pending.find((q) => q.id === id);
+	if (p === void 0) return void 0;
+	return isOutboxed(p) && isEphemeral(s, p.command.protocol) ? {
+		protocol: p.command.protocol,
+		stored: toOutbox(p)
+	} : { protocol: p.command.protocol };
+};
+const settleReleases = (s, id, outcome) => {
+	const waiters = s.releases.get(id);
+	if (waiters === void 0) return;
+	s.releases.delete(id);
+	for (const waiter of waiters) if (outcome.ok) waiter.resolve(outcome.payload);
+	else waiter.reject(new StatewireSendError(outcome.failure));
+};
+const followReleases = (s) => {
+	for (const id of [...s.releases.keys()]) {
+		if (locate(s, id) !== void 0) continue;
+		const lanes = Object.values(s.record.lanes);
+		const notice = lanes.flatMap((lane) => lane.inbox ?? []).find((n) => n.id === id);
+		const mark = lanes.flatMap((lane) => lane.removed ?? []).find((m) => m.id === id);
+		const failure = notice?.failure ?? mark?.failure;
+		settleReleases(s, id, failure ? {
+			ok: false,
+			failure
+		} : {
+			ok: true,
+			payload: notice?.result === void 0 ? void 0 : paramsOf({
+				params: notice.result.value,
+				meta: notice.result.meta
+			})[0]
+		});
+	}
+};
 const watchOwners = (s) => {
 	const owner = s.store.owner;
 	const shared = s.shared;
@@ -385,69 +470,125 @@ const cover = (s, entry) => {
 	s.lifecycle?.onApplied(entry.inv);
 	s.lifecycle?.onCovered?.(entry.inv);
 };
-const failedCommands = (s) => {
-	const parts = Object.values(s.record.lanes).flatMap((lane) => lane.failed === void 0 ? [] : [lane.failed]);
-	if (!(parts.length === s.failedParts.length && parts.every((part, i) => part === s.failedParts[i]))) {
-		s.failedParts = parts;
-		s.failedList = parts.flat();
-	}
-	return s.failedList;
-};
-const MAX_FAILED_RETAINED = 256;
-const boundFailed = (failed) => failed.length > 256 ? [...failed].sort((a, b) => a.ts - b.ts).slice(-256) : failed;
-const boundRecord = (record) => {
+const MAX_INBOX = 256;
+const updateOf = (protocol, stored) => ({
+	protocol,
+	id: stored.id,
+	method: stored.method,
+	params: paramsOf(stored),
+	...stored.seq !== void 0 && { seq: stored.seq },
+	status: "settled",
+	...stored.result !== void 0 && { result: paramsOf({
+		params: stored.result.value,
+		meta: stored.result.meta
+	})[0] },
+	...stored.failure !== void 0 && { failure: stored.failure },
+	...stored.localMeta !== void 0 && { localMeta: stored.localMeta }
+});
+const boundInbox = (store, record) => {
 	let lanes = record.lanes;
-	for (const [protocol, lane] of Object.entries(lanes)) if (lane.failed !== void 0 && lane.failed.length > 256) lanes = {
-		...lanes,
-		[protocol]: {
-			...lane,
-			failed: boundFailed(lane.failed)
-		}
-	};
+	const dropped = [];
+	for (const [protocol, lane] of Object.entries(lanes)) {
+		const inbox = lane.inbox;
+		if (inbox === void 0 || inbox.length <= 256) continue;
+		const sorted = [...inbox].sort((x, y) => x.ts - y.ts);
+		const cut = sorted.length - 256;
+		dropped.push(...sorted.slice(0, cut).map((n) => updateOf(protocol, n)));
+		lanes = {
+			...lanes,
+			[protocol]: {
+				...lane,
+				inbox: sorted.slice(cut)
+			}
+		};
+	}
+	if (dropped.length > 0) store.onEvict?.({
+		reason: "inbox",
+		dropped
+	});
 	return lanes === record.lanes ? record : {
 		...record,
 		lanes
 	};
 };
-const retainFailedInner = (s, entry, failure) => {
-	const lane = laneOf(s.record, entry.command.protocol);
-	setRecord(s, withLane(s.record, entry.command.protocol, {
+const toNotice = (stored, outcome) => {
+	const result = outcome.ok ? encodeParams(outcome.payload === void 0 ? [] : [outcome.payload]) : void 0;
+	return {
+		id: stored.id,
+		method: stored.method,
+		params: stored.params,
+		...stored.meta !== void 0 && { meta: stored.meta },
+		ts: stored.ts,
+		...stored.seq !== void 0 && { seq: stored.seq },
+		...stored.localMeta !== void 0 && { localMeta: stored.localMeta },
+		...result !== void 0 && { result: {
+			value: result.params,
+			...result.meta !== void 0 && { meta: result.meta }
+		} },
+		...!outcome.ok && { failure: outcome.failure }
+	};
+};
+const lostNotice = (stored) => toNotice(stored, {
+	ok: false,
+	failure: LOST
+});
+const LOST = {
+	fate: "lost",
+	cause: "session-lost"
+};
+const withNotices = (lane, notices) => {
+	const known = new Set((lane.inbox ?? []).map((n) => n.id));
+	const added = notices.filter((n) => !known.has(n.id));
+	return added.length === 0 ? lane : {
 		...lane,
-		failed: boundFailed([...lane.failed ?? [], {
-			protocol: entry.command.protocol,
-			...entry.command.produced !== void 0 && { produced: entry.command.produced },
-			command: entry.command.method,
-			params: entry.command.params,
-			...entry.command.meta !== void 0 && { meta: entry.command.meta },
-			failure,
-			ts: entry.inv.ts,
-			seq: entry.seq
-		}])
-	}));
-	s.notify();
+		inbox: [...lane.inbox ?? [], ...added]
+	};
 };
-const retainFailed = (s, entry, failure) => {
-	if (!s.shared) {
-		retainFailedInner(s, entry, failure);
+const noticeInner = (s, notices) => {
+	let record = s.record;
+	for (const { entry, outcome } of notices) {
+		const protocol = entry.command.protocol;
+		const lane = laneOf(record, protocol);
+		record = withLane(record, protocol, {
+			...withNotices(lane, [toNotice(toStored(s, entry), outcome)]),
+			commands: lane.commands.filter((c) => c.id !== entry.id)
+		});
+	}
+	setRecord(s, boundInbox(s.store, record));
+	deliver(s);
+};
+const notice = (s, entry, outcome) => {
+	if (!s.shared || s.shared.inTx) {
+		noticeInner(s, [{
+			entry,
+			outcome
+		}]);
 		return;
 	}
-	transactBackground(s, () => retainFailedInner(s, entry, failure));
+	s.shared.notices.push({
+		entry,
+		outcome
+	});
+	syncBacklog(s);
 };
-const settleEntry = (s, entry, outcome) => {
+const settleEntry = (s, entry, outcome, mode = "notice") => {
 	s.pending = s.pending.filter((p) => p !== entry);
+	if (s.shared && !entry.adopted) s.shared.settled.add(entry.id);
+	settleReleases(s, entry.id, outcome);
+	const durable = mode === "noticed" || mode === "notice" && (outcome.ok || outcome.failure.cause !== "unmount") && isStamped(entry) && !isEphemeral(s, entry.command.protocol);
+	if (durable && mode === "notice") notice(s, entry, outcome);
 	if (outcome.ok) {
 		entry.resolve(outcome.payload);
 		s.lifecycle?.onSettle(entry.inv, {
 			type: "accepted",
 			payload: outcome.payload
-		});
+		}, durable);
 	} else {
-		if (!(outcome.failure.cause === "unmount") && isStamped(entry) && !entry.adopted && !isEphemeral(s, entry.command.protocol)) retainFailed(s, entry, outcome.failure);
 		entry.reject(new StatewireSendError(outcome.failure));
 		s.lifecycle?.onSettle(entry.inv, {
 			type: "rejected",
 			error: new StatewireSendError(outcome.failure)
-		});
+		}, durable);
 	}
 };
 const settleAll = (s, detach) => {
@@ -508,7 +649,10 @@ const settleRemoved = (s, entry) => {
 const requeue = (s, survivors) => {
 	for (const old of survivors) {
 		s.lifecycle?.onCovered?.(old.inv);
-		enqueueInner(s, old.command, old.inv.params, old.resolve, old.reject, old.inv.hold);
+		enqueueInner(s, old.command, old.inv.params, old.resolve, old.reject, {
+			...old.inv.held && { hold: true },
+			...old.inv.localMeta !== void 0 && { localMeta: old.inv.localMeta }
+		});
 	}
 };
 const rebaseRecord = (s, adopt) => {
@@ -522,15 +666,14 @@ const rebaseRecord = (s, adopt) => {
 	adopt();
 	let lanes = s.record.lanes;
 	for (const [protocol, lane] of Object.entries(previous)) {
-		const failed = lane.failed;
-		if (failed === void 0 || laneOf(s.record, protocol).failed === failed) continue;
-		const current = laneOf(s.record, protocol);
+		const current = laneOf({
+			...s.record,
+			lanes
+		}, protocol);
+		if (!lane.inbox?.length || current.inbox === lane.inbox) continue;
 		lanes = {
 			...lanes,
-			[protocol]: {
-				...current,
-				failed: boundFailed([...current.failed ?? [], ...failed])
-			}
+			[protocol]: withNotices(current, lane.inbox)
 		};
 	}
 	if (lanes !== s.record.lanes) setRecord(s, {
@@ -548,7 +691,7 @@ const resetRecord = (s, clientId) => rebaseRecord(s, () => setRecord(s, {
 }));
 const adoptReset = (s, stored) => {
 	rebaseRecord(s, () => {
-		s.record = boundRecord(stored);
+		s.record = boundInbox(s.store, stored);
 	});
 	if (s.attach === "attached") s.transport?.connection.reconnect();
 };
@@ -725,17 +868,13 @@ const publishIngested = (s) => {
 	wake(s);
 };
 const sessionLostInner = (s, protocol, seqWm) => {
+	const lane = laneOf(s.record, protocol);
+	const failure = {
+		fate: "lost",
+		cause: "session-lost"
+	};
 	const held = laneEntries(s, protocol);
-	settleLost(s, held);
 	s.durableSeq[protocol] = seqWm;
-	const { failed, outbox, removed } = laneOf(s.record, protocol);
-	setRecord(s, withLane(s.record, protocol, {
-		nextSeq: seqWm + 1,
-		commands: [],
-		...outbox !== void 0 && { outbox },
-		...removed !== void 0 && { removed },
-		...failed !== void 0 && { failed }
-	}));
 	if (held.length > 0 && s.onSessionLost?.(held.map((p) => ({
 		id: p.id,
 		method: p.inv.method,
@@ -743,11 +882,51 @@ const sessionLostInner = (s, protocol, seqWm) => {
 		ts: p.inv.ts,
 		seq: p.seq,
 		...p.inv.clientId !== void 0 && { clientId: p.inv.clientId }
-	}))) === "requeue") for (const old of held) enqueueInner(s, old.command, old.inv.params, () => {}, () => {});
+	}))) === "requeue") {
+		if (s.onDeprecatedPath) s.onDeprecatedPath({
+			kind: "session-lost-requeue",
+			count: held.length
+		});
+		else console.warn(`statewire: onSessionLost "requeue" re-enqueued ${held.length} commands; it is deprecated and will be removed`);
+		for (const p of held) {
+			s.lifecycle?.onCovered?.(p.inv);
+			settleEntry(s, p, {
+				ok: false,
+				failure
+			}, "memory");
+		}
+		setRecord(s, withLane(s.record, protocol, {
+			...lane,
+			nextSeq: seqWm + 1,
+			commands: []
+		}));
+		for (const old of held) enqueueInner(s, old.command, old.inv.params, () => {}, () => {}, { ...old.inv.localMeta !== void 0 && { localMeta: old.inv.localMeta } });
+	} else {
+		const stamps = mergeBacklog(s, protocol);
+		const queued = outboxOf(lane);
+		const { outbox: _outbox, ...rest } = lane;
+		setRecord(s, withLane(s.record, protocol, {
+			...withNotices(rest, [...stamps.map((c) => lostNotice(c)), ...queued.map((c) => lostNotice(c))]),
+			nextSeq: seqWm + 1,
+			commands: [],
+			...marks(s, lane, [...stamps.map((c) => ({
+				id: c.id,
+				by: c.by ?? c.owner
+			})), ...queued], failure)
+		}));
+		for (const p of s.pending.filter((q) => q.command.protocol === protocol)) {
+			s.lifecycle?.onCovered?.(p.inv);
+			settleEntry(s, p, {
+				ok: false,
+				failure
+			}, "noticed");
+		}
+		deliver(s);
+	}
 	publish(s);
 	wake(s);
 };
-const demote = (s, protocol, watermark, demoted) => {
+const demote = (s, protocol, watermark, demoted, waiting) => {
 	const lane = laneOf(s.record, protocol);
 	const local = laneEntries(s, protocol).filter((p) => p.seq > watermark);
 	const above = new Map(lane.commands.filter((c) => c.seq > watermark).map((c) => [c.id, c]));
@@ -758,6 +937,12 @@ const demote = (s, protocol, watermark, demoted) => {
 		sessionLostInner(s, protocol, watermark);
 		return;
 	}
+	const me = s.store.owner?.id;
+	const foreign = moved.find((c) => c.owner !== void 0 && c.owner !== me && !local.some((p) => p.id === c.id));
+	if (foreign !== void 0) {
+		for (const p of local) if (p.seq > foreign.seq) waiting.add(p);
+		return;
+	}
 	setRecord(s, withLane(s.record, protocol, {
 		...withOutbox(lane, [...moved.map(({ seq: _seq, owner: _owner, ...command }) => command), ...outboxOf(lane)]),
 		nextSeq: watermark + 1,
@@ -768,6 +953,19 @@ const demote = (s, protocol, watermark, demoted) => {
 	else unstamp(s, p);
 	sortPending(s);
 };
+const recheckLater = (s, watermarks) => {
+	if (s.rechecks.watermarks !== watermarks) s.rechecks = {
+		watermarks,
+		count: 0
+	};
+	s.rechecks.count += 1;
+	if (s.recheck !== void 0) return;
+	s.recheck = setTimeout(() => {
+		s.recheck = void 0;
+		if (s.running && s.attach === "attached") s.transport?.connection.reconnect();
+	}, backoff(s.rechecks.count + 1));
+};
+const gapFill = (s) => s.selection !== void 0 && s.selection.version >= "2026-11-01";
 const selectionOf = (syn) => {
 	if (syn.version === void 0 || syn.protocols === void 0) return void 0;
 	return {
@@ -807,18 +1005,24 @@ const handleHello = (s, { ops, syn }) => {
 	s.attachEntries = /* @__PURE__ */ new Set();
 	const reconcile = () => {
 		const demoted = /* @__PURE__ */ new Set();
+		const waiting = /* @__PURE__ */ new Set();
 		for (const lane of lanes) {
 			if (lane.record === "ephemeral") {
 				s.ephemeralSeqs[lane.name] = Math.max(Object.hasOwn(s.ephemeralSeqs, lane.name) ? s.ephemeralSeqs[lane.name] : 0, ...laneEntries(s, lane.name).map((p) => p.seq));
 				continue;
 			}
-			demote(s, lane.name, lane.seq ?? 0, demoted);
+			demote(s, lane.name, lane.seq ?? 0, demoted, waiting);
 			s.durableSeq[lane.name] = lane.seq ?? 0;
 		}
 		for (const entry of s.pending) {
-			entry.posted = attached.has(entry) || isStamped(entry) && entry.seq <= durableSeqOf(s, entry.command.protocol) && !isEphemeral(s, entry.command.protocol);
+			entry.posted = attached.has(entry) || waiting.has(entry) || isStamped(entry) && entry.seq <= durableSeqOf(s, entry.command.protocol) && !isEphemeral(s, entry.command.protocol);
 			entry.stale = false;
 		}
+		if (waiting.size > 0) recheckLater(s, JSON.stringify(lanes.map((lane) => [lane.name, lane.seq])));
+		else s.rechecks = {
+			watermarks: "",
+			count: 0
+		};
 		syncBacklogInner(s);
 		s.sessionKnown = true;
 		flushInner(s, demoted);
@@ -827,11 +1031,13 @@ const handleHello = (s, { ops, syn }) => {
 		reconcile();
 		publishIngested(s);
 		pump(s);
+		deliver(s);
 		return;
 	}
 	transactBackground(s, reconcile, () => {
 		publishIngested(s);
 		pump(s);
+		deliver(s);
 	});
 };
 const handleOps = (s, { ops, cmds }) => {
@@ -976,12 +1182,13 @@ const pump = async (s) => {
 			if (!s.hydrated) await s.ready;
 			const transport = s.transport;
 			const flushable = flushCandidates(s).length > 0;
-			const queued = s.pending.some((p) => isOutboxed(p) && p.inv.hold === void 0);
+			const queued = s.pending.some((p) => isOutboxed(p) && !p.inv.held) || queuedInRecord(s);
 			if (buildLanes(s) === null && !flushable && (!queued || s.attach === "attached")) return;
-			if (transport?.parked && s.pending.length === 0) return;
+			const waiting = s.pending.length > 0 || queued;
+			if (transport?.parked && !waiting) return;
 			if (s.attach !== "attached" || !transport) {
-				if (s.pending.length === 0) return;
-				if (transport?.connection.status === "standby" && transport.connection.reason === "idle" || transport?.parked && s.pending.length > 0) transport.connection.reconnect();
+				if (!waiting) return;
+				if (transport?.connection.status === "standby" && transport.connection.reason === "idle" || transport?.parked) transport.connection.reconnect();
 				await waitForWake(s);
 				continue;
 			}
@@ -1011,14 +1218,22 @@ const pump = async (s) => {
 					for (const entry of built.entries) entry.attempted = true;
 					return transport.send(built.frame);
 				};
-				result = await (s.shared && !s.deactivated && lanes.entries.length > 0 ? s.store.lock(() => {
-					refresh(s);
+				result = await (s.shared && !s.deactivated && lanes.entries.length > 0 ? s.store.lock(async () => {
+					refresh(s, await readStored(s));
 					lanes = buildLanes(s);
 					if (!lanes || epoch !== s.attachEpoch) return null;
 					return send(lanes);
 				}) : send(lanes));
 			} catch {
 				if (!s.running || isFinished(s)) return;
+				if (lanes !== null && lanes.entries.length > 0 && gapFill(s)) {
+					if (epoch !== s.attachEpoch) continue;
+					for (const entry of lanes.entries) if (s.pending.includes(entry)) entry.posted = true;
+					s.frameFailures += 1;
+					await sleepUntilWake(s, backoff(s.frameFailures));
+					if (s.running && epoch === s.attachEpoch && s.attach === "attached") transport.connection.reconnect();
+					continue;
+				}
 				if (lanes?.frame.ctx?.length) {
 					s.lanesOnAttach = true;
 					transport.connection.reconnect();
@@ -1077,6 +1292,7 @@ const start = (s) => {
 			transactBackground(s, () => consumeVerdicts(s), () => {
 				wake(s);
 				pump(s);
+				deliver(s);
 			});
 		});
 		s.running = true;
@@ -1085,7 +1301,10 @@ const start = (s) => {
 			s.recordPersisted = true;
 			adoptOwner(s, void 0);
 			consumeVerdicts(s);
-		}, () => void pump(s));
+		}, () => {
+			pump(s);
+			deliver(s);
+		});
 		return;
 	}
 	if (!s.recordPersisted) {
@@ -1095,9 +1314,12 @@ const start = (s) => {
 	adoptOwner(s, void 0);
 	s.running = true;
 	pump(s);
+	deliver(s);
 };
 const stop = (s) => {
 	s.running = false;
+	clearTimeout(s.recheck);
+	s.recheck = void 0;
 	if (s.shared) {
 		s.shared.unsubscribe?.();
 		s.shared.unsubscribe = null;
@@ -1113,7 +1335,12 @@ const setTransport = (s, transport) => {
 	s.transport = transport;
 	wake(s);
 };
-const enqueueInner = (s, command, params, resolve, reject, hold) => {
+const QUOTA = {
+	fate: "aborted",
+	cause: "quota"
+};
+const isQuota = (error) => error instanceof Error && error.name === "StatewireQuotaError";
+const enqueueInner = (s, command, params, resolve, reject, options = {}) => {
 	const protocol = command.protocol;
 	const id = randomId();
 	const entry = {
@@ -1127,7 +1354,8 @@ const enqueueInner = (s, command, params, resolve, reject, hold) => {
 			ts: Date.now(),
 			id,
 			clientId: s.record.clientId,
-			...hold !== void 0 && { hold }
+			...options.hold && { held: true },
+			...options.localMeta !== void 0 && { localMeta: options.localMeta }
 		},
 		adopted: false,
 		by: s.store.owner?.id,
@@ -1139,30 +1367,38 @@ const enqueueInner = (s, command, params, resolve, reject, hold) => {
 		resolve,
 		reject
 	};
-	s.pending.push(entry);
 	if (!isEphemeral(s, protocol)) {
 		const lane = laneOf(s.record, protocol);
-		setRecord(s, withLane(s.record, protocol, withOutbox(lane, [...outboxOf(lane), toOutbox(entry)])));
+		try {
+			setRecord(s, withLane(s.record, protocol, withOutbox(lane, [...outboxOf(lane), toOutbox(entry)])));
+		} catch (error) {
+			if (!isQuota(error)) throw error;
+			reject(new StatewireSendError(QUOTA));
+			return;
+		}
+		s.pending.push(entry);
 		reorder(s, protocol);
-	}
+	} else s.pending.push(entry);
 	s.lifecycle?.onStart(entry.inv);
 	s.notify();
 };
 const negotiated = (s, protocol) => s.selection?.protocols.some((p) => p.name === protocol) ?? false;
-const views = /* @__PURE__ */ new WeakMap();
-const viewOf = (protocol, stored) => {
-	const cached = views.get(stored);
+const viewOf = (s, protocol, stored, state) => {
+	const cached = s.views.get(stored);
 	if (cached?.protocol === protocol) return cached;
 	const view = {
 		id: stored.id,
 		protocol,
 		command: {
 			method: stored.method,
-			params: stored.meta === void 0 ? stored.params : reviveDocumentValue(structuredClone(stored.params), stored.meta)
+			params: paramsOf(stored)
 		},
-		held: stored.hold === void 0 ? null : { meta: stored.hold.meta }
+		ts: stored.ts,
+		state: state ?? (stored.held ? "held" : "queued"),
+		localMeta: stored.localMeta,
+		durable: s.store.durable !== false && !isEphemeral(s, protocol)
 	};
-	views.set(stored, view);
+	s.views.set(stored, view);
 	return view;
 };
 /** The lane's outbox as this client may flush it: the record's on a durable lane, its own on an ephemeral one. */
@@ -1171,7 +1407,7 @@ const bubble = (s, protocol, queue) => {
 	const may = s.options.canOvertake?.[protocol];
 	const order = [];
 	for (const stored of queue) {
-		if (stored.hold !== void 0) {
+		if (stored.held) {
 			order.push({
 				stored,
 				blocked: true
@@ -1179,7 +1415,7 @@ const bubble = (s, protocol, queue) => {
 			continue;
 		}
 		let at = order.length;
-		while (at > 0 && order[at - 1].blocked && may !== void 0 && may(viewOf(protocol, stored), viewOf(protocol, order[at - 1].stored))) at--;
+		while (at > 0 && order[at - 1].blocked && may !== void 0 && may(viewOf(s, protocol, stored), viewOf(s, protocol, order[at - 1].stored))) at--;
 		order.splice(at, 0, {
 			stored,
 			blocked: at > 0 && order[at - 1].blocked
@@ -1208,8 +1444,30 @@ const flushCandidates = (s) => flushLanes(s).flatMap((protocol) => {
 		stored
 	}));
 });
+const queuedInRecord = (s) => Object.keys(s.record.lanes).some((protocol) => (s.selection ? negotiated(s, protocol) : offered(s, protocol)) && bubble(s, protocol, laneQueue(s, protocol)).free > 0);
 const reasonOf = (s, stored, demoted) => stored.released ? "release" : demoted.has(stored.id) ? "reconnect" : s.mountIds.has(stored.id) ? "reload" : "enqueue";
 const NO_IDS = /* @__PURE__ */ new Set();
+const patched = (stored, patch) => {
+	const { held: _held, released: _released, localMeta: _meta, ...rest } = stored;
+	const held = patch.held ?? stored.held === true;
+	const localMeta = patch.localMeta === void 0 ? stored.localMeta : patch.localMeta.value;
+	let next = {
+		...rest,
+		...held && { held: true },
+		...!held && (stored.held || stored.released) && { released: true },
+		...localMeta !== void 0 && { localMeta }
+	};
+	if (patch.params !== void 0) {
+		const { params, meta } = encodeParams(patch.params);
+		const { meta: _old, ...plain } = next;
+		next = {
+			...plain,
+			params,
+			...meta !== void 0 && { meta }
+		};
+	}
+	return next;
+};
 const flushInner = (s, demoted = NO_IDS) => {
 	if (s.attach !== "attached" || !s.sessionKnown || !s.running || isFinished(s)) return;
 	const candidates = flushCandidates(s);
@@ -1217,11 +1475,11 @@ const flushInner = (s, demoted = NO_IDS) => {
 	const groups = /* @__PURE__ */ new Map();
 	for (const { protocol, stored } of candidates) {
 		const reason = reasonOf(s, stored, demoted);
-		groups.set(reason, [...groups.get(reason) ?? [], viewOf(protocol, stored)]);
+		groups.set(reason, [...groups.get(reason) ?? [], viewOf(s, protocol, stored)]);
 	}
 	const flushing = {
 		ids: new Set(candidates.map((c) => c.stored.id)),
-		held: /* @__PURE__ */ new Map(),
+		patches: /* @__PURE__ */ new Map(),
 		removed: /* @__PURE__ */ new Set()
 	};
 	s.flushing = flushing;
@@ -1250,17 +1508,14 @@ const flushInner = (s, demoted = NO_IDS) => {
 				if (own) settleRemoved(s, own);
 				continue;
 			}
-			const hold = flushing.held.get(stored.id);
-			if (hold === void 0) {
+			const patch = flushing.patches.get(stored.id);
+			if (patch === void 0) {
 				queue.push(stored);
 				continue;
 			}
-			const { released: _released, ...rest } = stored;
-			queue.push({
-				...rest,
-				hold
-			});
-			if (own) setHold(s, own, hold);
+			const next = patched(stored, patch);
+			queue.push(next);
+			if (own) follow(s, own, next);
 		}
 		const { order, free } = bubble(s, protocol, queue);
 		let nextSeq = lane.nextSeq;
@@ -1276,7 +1531,7 @@ const flushInner = (s, demoted = NO_IDS) => {
 			}
 			const seq = Math.max(nextSeq, durableSeqOf(s, protocol) + 1);
 			nextSeq = seq + 1;
-			const { hold: _hold, released: _released, ...command } = stored;
+			const { held: _held, released: _released, ...command } = stored;
 			const stamped = {
 				...command,
 				seq,
@@ -1313,81 +1568,262 @@ const flush = (s) => {
 	return transact(s, () => flushInner(s));
 };
 const outboxEntries = (s) => {
-	const local = s.pending.filter((p) => isOutboxed(p) && isEphemeral(s, p.command.protocol));
-	const parts = [
-		...Object.values(s.record.lanes).map((lane) => lane.outbox),
-		...local.map((p) => p.inv.hold),
-		...local
-	];
+	const local = s.pending.filter((p) => isEphemeral(s, p.command.protocol) && !p.away);
+	const parts = [...Object.values(s.record.lanes).flatMap((lane) => [lane.commands, lane.outbox]), ...local.flatMap((p) => [
+		p,
+		p.seq,
+		p.inv.held,
+		p.inv.localMeta
+	])];
 	if (!(parts.length === s.outboxParts.length && parts.every((part, i) => part === s.outboxParts[i]))) {
 		s.outboxParts = parts;
-		s.outboxList = [...Object.entries(s.record.lanes).flatMap(([protocol, lane]) => outboxOf(lane).map((c) => viewOf(protocol, c))), ...local.map((p) => viewOf(p.command.protocol, toOutbox(p)))];
+		s.outboxList = [...Object.entries(s.record.lanes).flatMap(([protocol, lane]) => [...[...lane.commands].sort((a, b) => a.seq - b.seq).map((c) => viewOf(s, protocol, c, "sending")), ...outboxOf(lane).map((c) => viewOf(s, protocol, c))]), ...[...local].sort((a, b) => (a.seq ?? Infinity) - (b.seq ?? Infinity)).map((p) => isStamped(p) ? viewOf(s, p.command.protocol, toStored(s, p), "sending") : viewOf(s, p.command.protocol, toOutbox(p)))];
 	}
 	return s.outboxList;
 };
-const applyOutboxOp = (s, protocol, id, op) => {
-	const done = op.type === "hold" ? "held" : op.type === "release" ? "released" : "removed";
+const entryOf = (s, id) => {
+	const at = locate(s, id);
+	if (at === void 0) throw new Error(`outbox: no entry ${id}`);
+	if (at.stored === void 0) throw new Error(`outbox: ${id} is in flight`);
+	return {
+		protocol: at.protocol,
+		stored: at.stored
+	};
+};
+const applyOutboxOp = (s, id, op) => {
+	const at = locate(s, id);
+	if (at?.stored === void 0) return;
+	const { protocol, stored } = at;
 	const own = s.pending.find((p) => p.id === id && isOutboxed(p));
-	const lane = laneOf(s.record, protocol);
-	const stored = outboxOf(lane).find((c) => c.id === id);
-	if (!stored) {
-		if (op.type === "remove" && lane.removed?.some((m) => m.id === id)) return "removed";
-		if (!own || !isEphemeral(s, protocol)) return "stamped";
-	} else if (op.type === "remove") setRecord(s, withLane(s.record, protocol, {
-		...withOutbox(lane, outboxOf(lane).filter((c) => c.id !== id)),
-		...marks(s, lane, [stored])
-	}));
-	else {
-		const { hold: _hold, released: _released, ...queued } = stored;
-		const next = op.type === "hold" ? {
-			...queued,
-			hold: op.hold
-		} : stored.hold === void 0 && !stored.released ? queued : {
-			...queued,
-			released: true
-		};
-		setRecord(s, withLane(s.record, protocol, withOutbox(lane, outboxOf(lane).map((c) => c.id === id ? next : c))));
-	}
-	if (own) {
-		if (op.type === "remove") settleRemoved(s, own);
-		else setHold(s, own, op.type === "hold" ? op.hold : void 0);
+	if (op.type === "remove") {
+		if (!isEphemeral(s, protocol)) {
+			const lane = laneOf(s.record, protocol);
+			setRecord(s, withLane(s.record, protocol, {
+				...withOutbox(lane, outboxOf(lane).filter((c) => c.id !== id)),
+				...marks(s, lane, [stored])
+			}));
+		}
+		if (own) settleRemoved(s, own);
+	} else {
+		const next = patched(stored, op.patch(viewOf(s, protocol, stored)));
+		if (!isEphemeral(s, protocol)) {
+			const lane = laneOf(s.record, protocol);
+			setRecord(s, withLane(s.record, protocol, withOutbox(lane, outboxOf(lane).map((c) => c.id === id ? next : c))));
+		}
+		if (own) follow(s, own, next);
 	}
 	reorder(s, protocol);
 	s.notify();
-	return done;
 };
-const outboxOp = (s, entry, op) => {
+const toPatch = (patch) => {
+	if (typeof patch !== "object" || patch === null) throw new Error("outbox: update must return a patch object");
+	if (patch.held !== void 0 && typeof patch.held !== "boolean") throw new Error("outbox: held must be a boolean");
+	if (patch.command !== void 0 && (Object.keys(patch.command).some((k) => k !== "params") || !Array.isArray(patch.command.params))) throw new Error("outbox: a patch may only replace command.params");
+	return {
+		...patch.held !== void 0 && { held: patch.held },
+		..."localMeta" in patch && { localMeta: { value: patch.localMeta } },
+		...patch.command !== void 0 && { params: patch.command.params }
+	};
+};
+const outboxOp = (s, id, op) => {
+	entryOf(s, id);
 	const flushing = s.flushing;
-	if (flushing?.ids.has(entry.id)) {
-		if (op.type === "remove") flushing.removed.add(entry.id);
-		else if (op.type === "hold") flushing.held.set(entry.id, op.hold);
-		else flushing.held.delete(entry.id);
-		return Promise.resolve(op.type === "hold" ? "held" : op.type === "release" ? "released" : "removed");
+	if (flushing?.ids.has(id)) {
+		if (op.type === "remove") flushing.removed.add(id);
+		else {
+			const at = entryOf(s, id);
+			const patch = op.patch(viewOf(s, at.protocol, at.stored));
+			flushing.patches.set(id, {
+				...flushing.patches.get(id),
+				...patch
+			});
+		}
+		return Promise.resolve();
 	}
-	let status = "stamped";
+	const done = () => {
+		wake(s);
+		pump(s);
+	};
+	if (!s.shared) {
+		applyOutboxOp(s, id, op);
+		done();
+		return Promise.resolve();
+	}
+	return transact(s, () => applyOutboxOp(s, id, op)).then(done);
+};
+const background = (promise) => {
+	promise.catch(() => {});
+};
+const holdOutbox = (s, id) => background(outboxOp(s, id, {
+	type: "patch",
+	patch: () => ({ held: true })
+}));
+const releaseOutbox = (s, id) => {
+	entryOf(s, id);
+	const result = new Promise((resolve, reject) => {
+		const waiters = s.releases.get(id) ?? [];
+		waiters.push({
+			resolve,
+			reject
+		});
+		s.releases.set(id, waiters);
+	});
+	result.catch(() => {});
+	outboxOp(s, id, {
+		type: "patch",
+		patch: () => ({ held: false })
+	}).catch((error) => settleWaiters(s, id, error));
+	return result;
+};
+const settleWaiters = (s, id, error) => {
+	const waiters = s.releases.get(id) ?? [];
+	s.releases.delete(id);
+	for (const waiter of waiters) waiter.reject(error);
+};
+const removeOutbox = (s, id) => background(outboxOp(s, id, { type: "remove" }));
+const updateOutbox = (s, id, fn) => background(outboxOp(s, id, {
+	type: "patch",
+	patch: (entry) => toPatch(fn(entry))
+}));
+const producedOf = (s) => ({
+	wire: s.options.wireVersion ?? { version: "2026-11-01" },
+	protocols: protocolOffers(s.options) === "*" && s.selection ? s.selection.protocols : protocolOffers(s.options)
+});
+const placed = (queue, entry, { after, before }) => {
+	const anchor = after ?? before;
+	if (anchor === void 0) return [...queue, entry];
+	const index = queue.findIndex((c) => c.id === anchor);
+	if (index === -1) return [...queue, entry];
+	const at = after !== void 0 ? index + 1 : index;
+	return [
+		...queue.slice(0, at),
+		entry,
+		...queue.slice(at)
+	];
+};
+const insertOutbox = (s, entry) => {
+	if (!s.hydrated) throw new Error("outbox: storage is not hydrated yet");
+	if (s.storageError !== void 0) throw s.storageError;
+	if (entry.after !== void 0 && entry.before !== void 0) throw new Error("outbox: after and before are exclusive");
+	for (const anchor of [entry.after, entry.before]) if (anchor !== void 0) entryOf(s, anchor);
+	const { protocol } = entry;
+	if (!(s.selection ? negotiated(s, protocol) : offered(s, protocol))) throw new Error(`statewire: protocol "${protocol}" is not negotiated`);
+	const { params, meta } = encodeParams(entry.command.params);
+	const id = entry.from === void 0 ? randomId() : `${entry.from}~`;
+	const stored = {
+		id,
+		produced: producedOf(s),
+		method: entry.command.method,
+		params,
+		...meta !== void 0 && { meta },
+		ts: Date.now(),
+		...entry.held && { held: true },
+		...entry.localMeta !== void 0 && { localMeta: entry.localMeta },
+		...s.store.owner !== void 0 && { by: s.store.owner.id }
+	};
 	const run = () => {
-		status = applyOutboxOp(s, entry.protocol, entry.id, op);
+		if (isEphemeral(s, protocol)) {
+			enqueueInner(s, {
+				protocol,
+				produced: stored.produced,
+				method: stored.method,
+				params,
+				...meta !== void 0 && { meta }
+			}, entry.command.params, () => {}, () => {}, {
+				...entry.held && { hold: true },
+				...entry.localMeta !== void 0 && { localMeta: entry.localMeta }
+			});
+			return;
+		}
+		let base = s.record;
+		if (entry.from !== void 0) {
+			const source = Object.entries(base.lanes).find(([, l]) => l.inbox?.some((n) => n.id === entry.from));
+			if (source === void 0 || locate(s, id) !== void 0) return;
+			base = withLane(base, source[0], withoutNotice(source[1], entry.from));
+		}
+		const lane = laneOf(base, protocol);
+		try {
+			setRecord(s, withLane(base, protocol, withOutbox(lane, placed(outboxOf(lane), stored, entry))));
+		} catch (error) {
+			if (!isQuota(error)) throw error;
+			if (entry.from !== void 0) s.skipped.add(entry.from);
+			settleReleases(s, id, {
+				ok: false,
+				failure: QUOTA
+			});
+			return;
+		}
+		s.mountIds.delete(id);
+		reorder(s, protocol);
+		s.notify();
 	};
 	const done = () => {
 		wake(s);
 		pump(s);
-		return status;
 	};
 	if (!s.shared) {
 		run();
-		return Promise.resolve(done());
+		done();
+	} else background(transact(s, run).then(done));
+	return id;
+};
+const nextNotice = (s) => {
+	for (const [protocol, lane] of Object.entries(s.record.lanes)) {
+		const found = (lane.inbox ?? []).find((n) => !s.skipped.has(n.id));
+		if (found) return {
+			protocol,
+			found
+		};
 	}
-	return transact(s, run).then(done);
 };
-const holdOutbox = (s, entry, meta) => outboxOp(s, entry, {
-	type: "hold",
-	hold: meta === void 0 ? {} : { meta }
-});
-const releaseOutbox = (s, entry) => outboxOp(s, entry, { type: "release" });
-const removeOutbox = (s, entry) => outboxOp(s, entry, { type: "remove" });
-const enqueue = (s, command, params, resolve, reject, hold) => {
+const withoutNotice = (lane, id) => {
+	const inbox = (lane.inbox ?? []).filter((n) => n.id !== id);
+	const { inbox: _inbox, ...rest } = lane;
+	return inbox.length > 0 ? {
+		...rest,
+		inbox
+	} : rest;
+};
+const ack = (s, protocol, id) => {
+	const lane = laneOf(s.record, protocol);
+	if (s.skipped.has(id) || !lane.inbox?.some((n) => n.id === id)) return;
+	setRecord(s, withLane(s.record, protocol, withoutNotice(lane, id)));
+};
+const deliver = (s) => {
+	const handler = s.onSettled;
+	if (handler === void 0 || s.delivering || !s.running || !s.hydrated || !s.sessionKnown) return;
+	if (nextNotice(s) === void 0) return;
+	s.delivering = true;
+	const run = async () => {
+		for (;;) {
+			if (s.shared) await transact(s, () => {});
+			else await null;
+			const next = nextNotice(s);
+			if (next === void 0 || !s.running) return;
+			const { protocol, found } = next;
+			try {
+				await handler(updateOf(protocol, found));
+			} catch (error) {
+				console.error("statewire: onCommandChange threw on a settled update; it stays for the next mount", error);
+				s.skipped.add(found.id);
+				continue;
+			}
+			if (s.shared) await transact(s, () => ack(s, protocol, found.id));
+			else ack(s, protocol, found.id);
+			s.notify();
+		}
+	};
+	(s.store.notifyLock ? s.store.notifyLock(run) : run()).then(() => {
+		s.delivering = false;
+		deliver(s);
+	}, (error) => {
+		s.delivering = false;
+		console.error("statewire: settled update delivery stopped", error);
+	});
+};
+const enqueue = (s, command, params, resolve, reject, options) => {
 	if (!s.shared) {
-		enqueueInner(s, command, params, resolve, reject, hold);
+		enqueueInner(s, command, params, resolve, reject, options);
 		wake(s);
 		pump(s);
 		return;
@@ -1400,7 +1836,7 @@ const enqueue = (s, command, params, resolve, reject, hold) => {
 			}));
 			return;
 		}
-		enqueueInner(s, command, params, resolve, reject, hold);
+		enqueueInner(s, command, params, resolve, reject, options);
 	}).then(() => {
 		wake(s);
 		pump(s);
@@ -1412,6 +1848,7 @@ const offered = (s, protocol) => {
 };
 const sendCommand = (s, method, params, protocol = s.options.protocol ?? "default", options) => {
 	if (!(s.selection ? s.selection.protocols.some((p) => p.name === protocol) : offered(s, protocol))) throw new Error(`statewire: protocol "${protocol}" is not negotiated`);
+	if (options?.hold !== void 0 && typeof options.hold !== "boolean") throw new Error("statewire: invoke hold must be a boolean");
 	if (!s.hydrated) {
 		const result = s.ready.then(() => sendCommand(s, method, params, protocol, options));
 		result.catch(() => {});
@@ -1434,93 +1871,14 @@ const sendCommand = (s, method, params, protocol = s.options.protocol ?? "defaul
 		const { params: encoded, meta } = encodeParams(params);
 		enqueue(s, {
 			protocol,
-			produced: {
-				wire: s.options.wireVersion ?? { version: "2026-11-01" },
-				protocols: protocolOffers(s.options) === "*" && s.selection ? s.selection.protocols : protocolOffers(s.options)
-			},
+			produced: producedOf(s),
 			method,
 			params: encoded,
 			...meta !== void 0 && { meta }
-		}, params, resolve, reject, options?.hold);
-	});
-	result.catch(() => {});
-	return result;
-};
-const findFailed = (s, entry) => (laneOf(s.record, entry.protocol).failed ?? []).find((f) => f.seq === entry.seq && f.ts === entry.ts && f.command === entry.command);
-const unknownFailed = (entry) => /* @__PURE__ */ new Error(`statewire: unknown failed command "${entry.command}"`);
-const takeFailed = (s, entry) => {
-	const lane = laneOf(s.record, entry.protocol);
-	const found = findFailed(s, entry);
-	if (found === void 0) throw unknownFailed(entry);
-	setRecord(s, withLane(s.record, entry.protocol, {
-		...lane,
-		failed: (lane.failed ?? []).filter((f) => f !== found)
-	}));
-	s.notify();
-	return found;
-};
-const discardFailed = (s, entry) => {
-	if (!s.shared) {
-		takeFailed(s, entry);
-		return;
-	}
-	if (findFailed(s, entry) === void 0) throw unknownFailed(entry);
-	transactBackground(s, () => {
-		if (findFailed(s, entry) !== void 0) takeFailed(s, entry);
-	});
-};
-const retryFailed = (s, entry) => {
-	if (!s.running) return rejectedSend({
-		fate: "aborted",
-		cause: "unmount"
-	});
-	if (isFinished(s)) return rejectedSend({
-		fate: "aborted",
-		cause: "stream-gone"
-	});
-	const found = findFailed(s, entry);
-	if (found === void 0) throw unknownFailed(entry);
-	const params = found.meta === void 0 ? found.params : reviveDocumentValue(structuredClone(found.params), found.meta);
-	const result = new Promise((resolve, reject) => {
-		const retry = () => {
-			if (!s.running) {
-				reject(new StatewireSendError({
-					fate: "aborted",
-					cause: "unmount"
-				}));
-				return;
-			}
-			if (isFinished(s)) {
-				reject(new StatewireSendError({
-					fate: "aborted",
-					cause: "stream-gone"
-				}));
-				return;
-			}
-			const current = findFailed(s, entry);
-			if (current === void 0) {
-				reject(unknownFailed(entry));
-				return;
-			}
-			takeFailed(s, current);
-			enqueueInner(s, {
-				protocol: current.protocol,
-				...current.produced !== void 0 && { produced: current.produced },
-				method: current.command,
-				params: [...current.params],
-				...current.meta !== void 0 && { meta: current.meta }
-			}, params, resolve, reject);
-		};
-		if (!s.shared) {
-			retry();
-			wake(s);
-			pump(s);
-			return;
-		}
-		transact(s, retry).then(() => {
-			wake(s);
-			pump(s);
-		}, reject);
+		}, params, resolve, reject, {
+			...options?.hold && { hold: true },
+			...options?.localMeta !== void 0 && { localMeta: options.localMeta }
+		});
 	});
 	result.catch(() => {});
 	return result;
@@ -1583,7 +1941,7 @@ const loadSessionRecord = (store, options) => {
 	const record = stored === null ? {
 		clientId: randomId(),
 		lanes: {}
-	} : boundRecord(stored);
+	} : boundInbox(store, stored);
 	if (record !== stored) store.save(record);
 	return record;
 };
@@ -1601,7 +1959,7 @@ const useStatewireSession = (options) => {
 	const documentStore = useContext(DocumentStorageContext);
 	if (options.sessionStore !== void 0 && mounted !== void 0) throw new Error("statewire: session storage is set twice — drop the transport's sessionStore or the client's storage.session");
 	const store = options.sessionStore ?? mounted ?? defaultStore;
-	if (store.lock === void 0 !== (store.subscribe === void 0) || store.lock === void 0 !== (store.owner === void 0)) throw new Error("statewire: session storage must provide lock, subscribe and owner together");
+	if (store.lock === void 0 !== (store.subscribe === void 0) || store.lock === void 0 !== (store.owner === void 0) || store.lock === void 0 !== (store.notifyLock === void 0)) throw new Error("statewire: session storage must provide lock, subscribe, owner and notifyLock together");
 	const [s] = useState(() => {
 		const record = store.ready === void 0 ? loadSessionRecord(store, options) : {
 			clientId: randomId(),
@@ -1640,6 +1998,9 @@ const useStatewireSession = (options) => {
 				txq: Promise.resolve(),
 				syncQueued: false,
 				parked: [],
+				settled: /* @__PURE__ */ new Set(),
+				notices: [],
+				inTx: false,
 				unsubscribe: null,
 				watched: /* @__PURE__ */ new Set(),
 				abort: null
@@ -1652,6 +2013,12 @@ const useStatewireSession = (options) => {
 			resumeAt: 0,
 			idle: false,
 			onSessionLost: void 0,
+			onDeprecatedPath: void 0,
+			onSettled: void 0,
+			releases: /* @__PURE__ */ new Map(),
+			delivering: false,
+			skipped: /* @__PURE__ */ new Set(),
+			views: /* @__PURE__ */ new WeakMap(),
 			onFlush: void 0,
 			onDone: void 0,
 			mountIds: storedIds(record),
@@ -1661,9 +2028,12 @@ const useStatewireSession = (options) => {
 			lanesOnAttach: false,
 			attachEntries: /* @__PURE__ */ new Set(),
 			frameFailures: 0,
+			recheck: void 0,
+			rechecks: {
+				watermarks: "",
+				count: 0
+			},
 			pending: [],
-			failedList: [],
-			failedParts: [],
 			canonical: void 0,
 			documentListeners: /* @__PURE__ */ new Set(),
 			documents: {
@@ -1724,6 +2094,8 @@ const useStatewireSession = (options) => {
 	s.store = store;
 	s.documentStore = documentStore;
 	s.onSessionLost = options.onSessionLost;
+	s.onDeprecatedPath = options.onDeprecatedPath;
+	s.onSettled = options.onSettled;
 	s.onFlush = options.onFlush;
 	s.onDone = options.onDone;
 	const keyPrefixes = JSON.stringify(options.keyPrefixes);
@@ -1743,6 +2115,6 @@ const useStatewireSession = (options) => {
 	}, [s]);
 	return s;
 };
-export { MAX_FAILED_RETAINED, discardFailed, documentSource, failedCommands, holdOutbox, invokeProtocol, outboxEntries, releaseOutbox, removeOutbox, retryFailed, setContext, setTransport, useStatewireSession };
+export { MAX_INBOX, documentSource, holdOutbox, insertOutbox, invokeProtocol, outboxEntries, releaseOutbox, removeOutbox, setContext, setTransport, updateOutbox, useStatewireSession };
 
 //# sourceMappingURL=session.js.map