@capxul/cli 4.20.0-beta.1 → 4.20.0-beta.2

package/dist/main.mjs

@@ -11120,6 +11120,9 @@ const moneyExecutionContract = {
 //#region ../../packages/sdk/src/ports/indexer-read.ts
 /** The indexer's own page bound. Exceeding it is a caller defect, not a refusal. */
 const INDEXER_MAX_LIMIT = 1e3;
+function validTime(value) {
+	return Number.isSafeInteger(value) && value >= 0 && value <= Math.floor(Number.MAX_SAFE_INTEGER / 1e3);
+}
 const LOWER_CASE_ADDRESS = /^0x[0-9a-f]{40}$/;
 /**
 * Refuse a page the indexer would refuse, before any implementation spends a
@@ -11127,12 +11130,21 @@ const LOWER_CASE_ADDRESS = /^0x[0-9a-f]{40}$/;
 * against the hermetic adapter cannot pass on input production rejects. Throws
 * a `CapxulError`; callers convert it to an `IndexerReadError`.
 */
+function assertEventLookup(input, id) {
+	if (input.limit !== 1 || (input.offset ?? 0) !== 0 || input.timeline !== void 0 || input.settlements !== void 0 || !/^[1-9][0-9]{0,9}:0x[0-9a-f]{64}:[0-9]{1,10}$/.test(id)) throw Errors.invalidInput("eventId", "must identify one logical event without another cursor");
+}
 function assertIndexerPage(input) {
 	const safe = String(input.safe).toLowerCase();
 	if (!LOWER_CASE_ADDRESS.test(safe)) throw Errors.invalidInput("safe", "must be a lower-case EVM address");
 	if (!Number.isSafeInteger(input.limit) || input.limit < 1 || input.limit > 1e3) throw Errors.invalidInput("limit", `must be an integer from 1 to ${INDEXER_MAX_LIMIT}`);
 	const offset = input.offset ?? 0;
 	if (!Number.isSafeInteger(offset) || offset < 0) throw Errors.invalidInput("offset", "must be a non-negative integer");
+	const timeline = input.timeline;
+	if (input.eventId !== void 0) assertEventLookup(input, input.eventId);
+	if (input.settlements !== void 0 && (offset !== 0 || timeline !== void 0 || input.settlements.length < 1 || input.settlements.length > 50 || !input.settlements.every((id) => /^0x[0-9a-f]{64}$/.test(id)))) throw Errors.invalidInput("settlements", "must hold 1 to 50 settlement IDs without another cursor");
+	if (timeline !== void 0) {
+		if (offset !== 0 || !validTime(timeline.from) || !validTime(timeline.to) || timeline.from > timeline.to || timeline.before !== void 0 && (!validTime(timeline.before.timestamp) || !/^[1-9][0-9]{0,9}:0x[0-9a-f]{64}:[0-9]{1,10}$/.test(timeline.before.id))) throw Errors.invalidInput("timeline", "must be a bounded time window with a logical event cursor and no offset");
+	}
 	return safe;
 }
 var IndexerReadError = class extends Data.TaggedError("IndexerReadError") {};
@@ -11162,20 +11174,6 @@ function directionFor(safe, transfer) {
 	if (from === safe && to === safe) return "self";
 	return to === safe ? "in" : "out";
 }
-/**
-* The Transfer a protocol Payment moved is the same money as its `payment`
-* row. One actor sees one item for it, so the Transfer is claimed and does not
-* become a second row. Another transfer in the same transaction that this
-* payment did not move stays unclaimed and keeps its own row.
-*/
-function claimedTransferIds(transfers, payments) {
-	const claimed = /* @__PURE__ */ new Set();
-	for (const payment of payments) {
-		const match = transfers.find((transfer) => !claimed.has(transfer.id) && transfer.txHash === payment.txHash && transfer.token.toLowerCase() === payment.token.toLowerCase() && transfer.amount === payment.amount && transfer.to.toLowerCase() === payment.recipient.toLowerCase());
-		if (match !== void 0) claimed.add(match.id);
-	}
-	return claimed;
-}
 function withAnnotation(item, annotation) {
 	return annotation?.counterpartyLabel === void 0 ? item : {
 		...item,
@@ -11186,10 +11184,14 @@ function withAnnotation(item, annotation) {
 * An indexed settlement confirms the intent. A missing row can be outside
 * this page or still backfilling; only the correction owner can prove rollback.
 */
-function confirmPayment(intent, chain) {
-	if (chain !== void 0) return {
+function confirmPayment(intent, chain, expected) {
+	if (chain !== void 0 && matchesPaymentFact(chain, expected)) return {
 		...intent,
 		status: "settled",
+		...intent.execution === void 0 ? {} : { execution: {
+			status: "settled",
+			retryRequired: false
+		} },
 		receipt: {
 			chainId: chain.chainId,
 			transactionHash: chain.txHash
@@ -11198,16 +11200,22 @@ function confirmPayment(intent, chain) {
 	};
 	return intent;
 }
+function matchesPaymentFact(chain, expected) {
+	return chain !== void 0 && expected !== void 0 && chain.chainId === expected.chainId && chain.contract.toLowerCase() === expected.contract.toLowerCase() && chain.sender.toLowerCase() === expected.sender.toLowerCase() && chain.recipient.toLowerCase() === expected.recipient.toLowerCase() && chain.token.toLowerCase() === expected.token.toLowerCase() && chain.amount.toString() === expected.rawAmount && chain.documentHash.toLowerCase() === expected.documentHash.toLowerCase() && chain.kind === expected.kind;
+}
 /**
 * One unclaimed Transfer as an Activity row, or `null` when this SDK cannot
 * denominate its asset. The indexer serves only configured assets, so a row
 * the registry does not know means the SDK and that deployment disagree; it is
 * dropped rather than shown with a guessed currency.
 */
+function isActivityVisible(item) {
+	return !(item.kind === "payment" && item.direction === "in" && item.execution?.notSent);
+}
 function transferItem(safe, transfer, annotation) {
 	const asset = configuredMoneyAssetById(transfer.assetId);
 	if (asset === null) return null;
-	const direction = directionFor(safe, transfer);
+	const direction = directionFor(safe.toLowerCase(), transfer);
 	const counterparty = direction === "in" ? transfer.from : transfer.to;
 	const at = blockMillis(transfer);
 	return withAnnotation({
@@ -11229,47 +11237,6 @@ function transferItem(safe, transfer, annotation) {
 		updatedAt: at
 	}, annotation);
 }
-/** Newest first. A Payment precedes a Movement at one instant, as the ledger reader orders them. */
-function compareItems(left, right) {
-	if (right.createdAt !== left.createdAt) return right.createdAt - left.createdAt;
-	if (left.kind !== right.kind) return left.kind === "payment" ? -1 : 1;
-	if (left.id === right.id) return 0;
-	return left.id < right.id ? 1 : -1;
-}
-function stitchActivity(input) {
-	const safe = input.safe.toLowerCase();
-	const chainBySettlement = /* @__PURE__ */ new Map();
-	for (const row of input.payments) chainBySettlement.set(row.settlementId.toLowerCase(), row);
-	const chainByPaymentId = /* @__PURE__ */ new Map();
-	for (const link of input.links) {
-		const row = chainBySettlement.get(link.settlementId.toLowerCase());
-		if (row !== void 0) chainByPaymentId.set(link.paymentId, row);
-	}
-	const annotations = /* @__PURE__ */ new Map();
-	for (const annotation of input.annotations) annotations.set(`${annotation.reference.kind}:${annotation.reference.id}`, annotation);
-	const items = [];
-	const claiming = [];
-	for (const intent of input.intents) {
-		if (intent.kind !== "payment") continue;
-		const chain = chainByPaymentId.get(intent.id);
-		if (chain !== void 0) claiming.push(chain);
-		items.push(withAnnotation(confirmPayment(intent, chain), annotations.get(`payment:${intent.id}`)));
-	}
-	const claimed = claimedTransferIds(input.transfers, claiming);
-	for (const transfer of input.transfers) {
-		if (claimed.has(transfer.id)) continue;
-		const item = transferItem(safe, transfer, annotations.get(`movement:${transfer.id}`));
-		if (item !== null) items.push(item);
-	}
-	return items.sort(compareItems);
-}
-/** The reference ids one stitched page needs its Convex overlay for. */
-function overlayReferences(items) {
-	return items.map((item) => ({
-		kind: item.kind,
-		id: item.id
-	}));
-}
 /**
 * Money in, money out and the pending share, one bucket per currency and
 * precision. Two assets that peg to the same currency at different precision
@@ -11288,7 +11255,7 @@ function summarizeItems(items) {
 		};
 		const raw = rawUnits(item.amount.value, item.amount.decimals);
 		if (item.kind === "payment" && item.status !== "settled") {
-			if (item.direction === "in" && item.status !== "cancelled" && item.status !== "failed") bucket.pendingIn += raw;
+			if (item.direction === "in" && item.status !== "cancelled" && item.status !== "failed" && !item.execution?.notSent) bucket.pendingIn += raw;
 		} else if (item.direction === "in") bucket.in += raw;
 		else if (item.direction === "out") bucket.out += raw;
 		buckets.set(key, bucket);
@@ -11311,179 +11278,412 @@ function rawUnits(value, decimals) {
 }
 //#endregion
 //#region ../../packages/sdk/src/surface/activity-read.ts
-/** How many Convex intent rows one page reads for its labels and pending rows. */
-const INTENT_WINDOW = 100;
-/** movement/annotations:overlay bounds each identifier array to 200. */
+const BATCH = 100;
 const MAX_OVERLAY_IDS = 200;
-/** The window a summary aggregates over. The indexer's own page bound. */
-const SUMMARY_WINDOW = INDEXER_MAX_LIMIT;
-function parseCursor(value) {
-	if (value === void 0) return 0;
-	try {
-		const parsed = JSON.parse(value);
-		return Number.isSafeInteger(parsed.offset) && parsed.offset >= 0 ? parsed.offset : 0;
-	} catch {
-		return 0;
-	}
+function actorKey(actor) {
+	return actor.kind === "account" ? `account:${actor.accountId}` : `organization:${actor.orgId}`;
+}
+function scopeKey(scope) {
+	return `${scope.principalAccountId ?? "legacy"}|${actorKey(scope.actor)}|${scope.safe?.toLowerCase() ?? "none"}`;
+}
+function selectionKey(params) {
+	const filter = params?.filter;
+	return JSON.stringify([
+		params?.range?.from ?? null,
+		params?.range?.to ?? null,
+		filter?.kind ?? null,
+		filter?.direction ?? null,
+		filter?.status === void 0 ? null : [...new Set(filter.status)].sort()
+	]);
+}
+function validString(value, max) {
+	return typeof value === "string" && value.length <= max;
+}
+function validPosition(position) {
+	return position === null || position !== void 0 && typeof position === "object" && Number.isSafeInteger(position.timestamp) && position.timestamp >= 0 && /^[1-9][0-9]{0,9}:0x[0-9a-f]{64}:[0-9]{1,10}$/.test(position.id);
+}
+function parseCursor(value, scope, selection) {
+	if (value === void 0) return null;
+	if (value.length > 4e4) throw Errors.invalidInput("cursor", "invalid Activity cursor");
+	const cursor = JSON.parse(value);
+	if (cursor === null || typeof cursor !== "object" || cursor.version !== 1 || cursor.scope !== scope || cursor.selection !== selection || !Number.isSafeInteger(cursor.checkpoint) || cursor.checkpoint < 0 || cursor.source !== "indexed" && cursor.source !== "fallback" || cursor.paymentCursor !== null && !validString(cursor.paymentCursor, 2048) || typeof cursor.paymentDone !== "boolean" || typeof cursor.transferDone !== "boolean" || typeof cursor.degraded !== "boolean" || !Array.isArray(cursor.paymentPending) || cursor.paymentPending.length > BATCH || new Set(cursor.paymentPending).size !== cursor.paymentPending.length || !cursor.paymentPending.every((id) => validString(id, 256)) || !validPosition(cursor.transferBefore)) throw Errors.invalidInput("cursor", "Activity scope or filters changed; restart from the first page");
+	return cursor;
 }
-function inRange(item, range) {
-	if (range?.from !== void 0 && item.createdAt < range.from) return false;
-	return range?.to === void 0 || item.createdAt <= range.to;
+function requireParams(params) {
+	const limit = params?.limit ?? 25;
+	if (!Number.isSafeInteger(limit) || limit < 1 || limit > BATCH) throw Errors.invalidInput("limit", "must be an integer from 1 to 100");
+	for (const value of [params?.range?.from, params?.range?.to]) if (value !== void 0 && !Number.isSafeInteger(value)) throw Errors.invalidInput("range", "must contain integer epoch milliseconds");
+	const f = params?.filter;
+	if (f?.kind !== void 0 && f.kind !== "payment" && f.kind !== "movement" || f?.direction !== void 0 && ![
+		"in",
+		"out",
+		"self"
+	].includes(f.direction) || f?.status !== void 0 && (!Array.isArray(f.status) || !f.status.every((status) => PAYMENT_STATUSES.includes(status)))) throw Errors.invalidInput("filter", "invalid Activity filter");
 }
-/** The caller's filter applied to the merged page. The join owns the order. */
 function matchesFilter(item, filter) {
-	if (filter === void 0) return true;
-	if (filter.kind !== void 0 && item.kind !== filter.kind) return false;
-	if (filter.direction !== void 0 && item.direction !== filter.direction) return false;
-	if (filter.status === void 0) return true;
-	return item.kind === "payment" && filter.status.includes(item.status);
+	return (filter?.kind === void 0 || item.kind === filter.kind) && (filter?.direction === void 0 || item.direction === filter.direction) && (filter?.status === void 0 || item.kind === "payment" && filter.status.includes(item.status));
 }
 function overlay(deps, actor, controls, input) {
 	const count = Math.max(input.references?.length ?? 0, input.settlementIds?.length ?? 0);
-	const offsets = Array.from({ length: Math.max(1, Math.ceil(count / MAX_OVERLAY_IDS)) }, (_, index) => index * MAX_OVERLAY_IDS);
+	const offsets = Array.from({ length: Math.max(1, Math.ceil(count / MAX_OVERLAY_IDS)) }, (_, i) => i * MAX_OVERLAY_IDS);
 	return Effect.forEach(offsets, (offset) => deps.convexCall.query(deps.functions.activityOverlay, copyInvocationObservation(controls, { input: {
 		...actor === void 0 ? {} : { actor },
 		...input.references === void 0 ? {} : { references: input.references.slice(offset, offset + MAX_OVERLAY_IDS) },
 		...input.settlementIds === void 0 ? {} : { settlementIds: input.settlementIds.slice(offset, offset + MAX_OVERLAY_IDS) }
-	} })), { concurrency: 2 }).pipe(Effect.map((pages) => ({
-		...pages[0],
-		links: pages.flatMap((page) => page.links),
-		annotations: pages.flatMap((page) => page.annotations)
-	})));
+	} })), { concurrency: 2 }).pipe(Effect.flatMap((pages) => {
+		const first = pages[0];
+		if (pages.some((page) => scopeKey(page) !== scopeKey(first))) return Effect.fail({ publicError: Errors.invalidInput("actor", "Activity scope changed during the read") });
+		return Effect.succeed({
+			...first,
+			links: pages.flatMap((page) => page.links),
+			annotations: pages.flatMap((page) => page.annotations),
+			...pages.every((page) => page.payments !== void 0) ? { payments: pages.flatMap((page) => page.payments ?? []) } : {}
+		});
+	}));
 }
 function convexPage(deps, actor, controls, input) {
 	return deps.convexCall.query(deps.functions.activityList, copyInvocationObservation(controls, { input: {
-		...actor === void 0 ? {} : { actor },
-		...input.cursor === void 0 ? {} : { cursor: input.cursor },
-		...input.limit === void 0 ? {} : { limit: input.limit },
-		...input.range === void 0 ? {} : { range: input.range }
+		...input,
+		actor
 	} }));
 }
-/** Both indexed tables for one Safe, or `null` when the indexer cannot answer. */
-function chainRows(deps, safe, limit) {
-	const page = {
-		safe,
-		limit: Math.min(limit, INDEXER_MAX_LIMIT)
-	};
-	return Effect.all([deps.indexer.read("transfer", page), deps.indexer.read("payment", page)], { concurrency: 2 }).pipe(Effect.map(([transfers, payments]) => ({
-		transfers,
-		payments
-	})), Effect.catch(() => Effect.succeed(null)));
+function chainRead(deps, table, input) {
+	return deps.indexer.read(table, input).pipe(Effect.catch((error) => {
+		if (error.publicError.details?.reason === "scope-refused" || ![
+			"NETWORK_ERROR",
+			"RATE_LIMITED",
+			"PROVIDER_ERROR",
+			"CAPABILITY_UNAVAILABLE",
+			"TIMEOUT"
+		].includes(error.publicCode)) return Effect.fail({ publicError: error.publicError });
+		return Effect.succeed(null);
+	}));
 }
-/** The stitched, filtered rows of one window, newest first. */
-function stitchedWindow(deps, actor, controls, window, params) {
+function fallbackPage(deps, scope, controls, params, state, degraded) {
 	return Effect.gen(function* () {
-		const scope = yield* overlay(deps, actor, controls, {});
-		const convex = yield* convexPage(deps, actor, controls, {
-			limit: INTENT_WINDOW,
-			...params.range === void 0 ? {} : { range: params.range }
+		const page = yield* convexPage(deps, scope.actor, controls, {
+			limit: params?.limit ?? 25,
+			...state.paymentCursor === null ? {} : { cursor: state.paymentCursor },
+			range: {
+				...params?.range?.from === void 0 ? {} : { from: params.range.from },
+				to: Math.min(state.checkpoint, params?.range?.to ?? state.checkpoint)
+			},
+			...params?.filter === void 0 ? {} : { filter: params.filter }
 		});
-		const rows = scope.safe === null ? null : yield* chainRows(deps, scope.safe, window);
-		if (rows === null || scope.safe === null) {
-			if (scope.safe !== null) yield* Effect.annotateCurrentSpan({
-				read_source: "convex",
-				read_warning: "indexer-unavailable"
-			});
-			return {
-				items: convex.items.filter((item) => matchesFilter(item, params.filter)),
-				stitched: false,
-				...scope.safe === null ? {} : { readWarning: "indexer-unavailable" }
-			};
+		const decoration = yield* overlay(deps, scope.actor, controls, { references: page.items.map((item) => ({
+			kind: item.kind,
+			id: item.id
+		})) });
+		if (scopeKey(decoration) !== scopeKey(scope)) return yield* Effect.fail({ publicError: Errors.invalidInput("actor", "Activity scope changed during fallback") });
+		const annotations = new Map(decoration.annotations.map((annotation) => [`${annotation.reference.kind}:${annotation.reference.id}`, annotation]));
+		yield* Effect.annotateCurrentSpan({
+			read_source: "convex",
+			...degraded ? { read_warning: "indexer-unavailable" } : {}
+		});
+		return {
+			...page,
+			items: page.items.filter(isActivityVisible).map((item) => withAnnotation(item, annotations.get(`${item.kind}:${item.id}`))),
+			checkpoint: state.checkpoint,
+			cursor: page.cursor === null ? null : JSON.stringify({
+				...state,
+				source: "fallback",
+				paymentCursor: page.cursor,
+				degraded
+			}),
+			...degraded ? { readWarning: "indexer-unavailable" } : {}
+		};
+	});
+}
+function boundedRange(range, checkpoint) {
+	return {
+		...range?.from === void 0 ? {} : { from: range.from },
+		to: Math.min(checkpoint, range?.to ?? checkpoint)
+	};
+}
+function unavailablePage(deps, scope, controls, params, state, first) {
+	if (first) return fallbackPage(deps, scope, controls, params, state, true);
+	return Effect.annotateCurrentSpan({
+		read_source: "indexer",
+		read_warning: "indexer-unavailable"
+	}).pipe(Effect.as({
+		items: [],
+		cursor: null,
+		checkpoint: state.checkpoint,
+		observedAt: Date.now(),
+		readWarning: "indexer-unavailable"
+	}));
+}
+function readTransfers(deps, safe, range, state, wanted, first) {
+	const from = Math.max(0, Math.ceil((range.from ?? 0) / 1e3));
+	const to = Math.floor(range.to / 1e3);
+	if (state.transferDone || from > to || !wanted && !first) return Effect.succeed([]);
+	return chainRead(deps, "transfer", {
+		safe: toAddress(safe),
+		limit: wanted ? BATCH : 1,
+		timeline: {
+			from,
+			to,
+			...state.transferBefore === null ? {} : { before: state.transferBefore }
 		}
-		yield* Effect.annotateCurrentSpan({ read_source: "indexer" });
-		const decoration = yield* overlay(deps, actor, controls, {
-			references: [...overlayReferences(convex.items), ...rows.transfers.map((row) => ({
+	});
+}
+function readPayments(deps, scope, controls, range, state, wanted) {
+	const done = state.paymentDone || !wanted;
+	if (state.paymentPending.length > 0 || done) return Effect.succeed({
+		items: [],
+		pending: state.paymentPending,
+		cursor: state.paymentCursor,
+		done
+	});
+	return convexPage(deps, scope.actor, controls, {
+		limit: BATCH,
+		range,
+		filter: { kind: "payment" },
+		...state.paymentCursor === null ? {} : { cursor: state.paymentCursor }
+	}).pipe(Effect.map((page) => ({
+		items: page.items,
+		pending: page.items.map((item) => item.id),
+		cursor: page.cursor,
+		done: page.cursor === null
+	})));
+}
+function readPaymentFacts(deps, safe, settlements) {
+	const offsets = Array.from({ length: Math.ceil(settlements.length / 50) }, (_, i) => i * 50);
+	return Effect.forEach(offsets, (offset) => chainRead(deps, "payment", {
+		safe: toAddress(safe),
+		limit: 50,
+		settlements: settlements.slice(offset, offset + 50)
+	}), { concurrency: 2 }).pipe(Effect.map((pages) => pages.some((page) => page === null) ? null : pages.flatMap((page) => page ?? [])));
+}
+function decoratePage(deps, scope, controls, transfers, page, range) {
+	return Effect.gen(function* () {
+		const decoration = yield* overlay(deps, scope.actor, controls, {
+			references: [...page.pending.map((id) => ({
+				kind: "payment",
+				id
+			})), ...transfers.map((row) => ({
 				kind: "movement",
 				id: row.id
 			}))],
-			settlementIds: rows.payments.map((row) => row.settlementId)
+			settlementIds: [...new Set(transfers.flatMap((row) => row.paymentSettlementId ? [row.paymentSettlementId] : []))]
 		});
-		const intents = [...convex.items];
-		const missing = new Set(decoration.links.map((link) => link.paymentId));
-		for (const item of intents) if (item.kind === "payment") missing.delete(item.id);
-		let cursor = convex.cursor;
-		while (missing.size > 0 && cursor !== null) {
-			const page = yield* convexPage(deps, actor, controls, {
-				limit: INTENT_WINDOW,
-				cursor,
-				...params.range === void 0 ? {} : { range: params.range }
-			});
-			for (const item of page.items) if (item.kind === "payment" && missing.delete(item.id)) intents.push(item);
-			cursor = page.cursor;
+		if (scopeKey(decoration) !== scopeKey(scope)) return yield* Effect.fail({ publicError: Errors.invalidInput("actor", "Activity scope changed during the read") });
+		const byId = new Map([...page.items, ...decoration.payments ?? []].map((item) => [item.id, item]));
+		const settlements = [...new Set(decoration.links.map((link) => link.settlementId))];
+		const facts = yield* readPaymentFacts(deps, scope.safe, settlements);
+		if (facts === null) return null;
+		const bySettlement = new Map(facts.map((row) => [row.settlementId, row]));
+		const byPayment = new Map(decoration.links.map((link) => [link.paymentId, {
+			fact: bySettlement.get(link.settlementId),
+			expected: link.expected
+		}]));
+		const annotations = new Map(decoration.annotations.map((annotation) => [`${annotation.reference.kind}:${annotation.reference.id}`, annotation]));
+		return {
+			payments: page.pending.flatMap((id) => {
+				const item = byId.get(id);
+				if (item === void 0 || item.kind !== "payment" || item.createdAt > range.to || range.from !== void 0 && item.createdAt < range.from) return [];
+				const confirmed = withAnnotation(confirmPayment(item, byPayment.get(id)?.fact, byPayment.get(id)?.expected), annotations.get(`payment:${id}`));
+				return isActivityVisible(confirmed) ? [confirmed] : [];
+			}),
+			annotations,
+			linked: new Set(decoration.links.filter((link) => matchesPaymentFact(bySettlement.get(link.settlementId), link.expected)).map((link) => link.settlementId))
+		};
+	});
+}
+function mergePage(safe, filter, limit, state, page, decoration, transfers, wantsTransfers) {
+	const { payments, annotations, linked } = decoration;
+	let pi = 0;
+	let ti = 0;
+	const items = [];
+	const transferEnd = !wantsTransfers || transfers.length < BATCH;
+	let transferBefore = state.transferBefore;
+	while (items.length < limit) {
+		if (pi === payments.length && !page.done || ti === transfers.length && !transferEnd) break;
+		const payment = payments[pi];
+		const row = transfers[ti];
+		if (payment === void 0 && row === void 0) break;
+		if (payment !== void 0 && (row === void 0 || payment.createdAt >= Number(row.timestamp) * 1e3)) {
+			pi += 1;
+			if (matchesFilter(payment, filter)) items.push(payment);
+		} else if (row !== void 0) {
+			ti += 1;
+			transferBefore = {
+				timestamp: Number(row.timestamp),
+				id: row.id
+			};
+			if (row.paymentSettlementId && linked.has(row.paymentSettlementId)) continue;
+			const item = transferItem(safe, row, annotations.get(`movement:${row.id}`));
+			if (item !== null && matchesFilter(item, filter)) items.push(item);
 		}
-		const older = intents.slice(convex.items.length);
-		const olderDecoration = older.length === 0 ? [] : (yield* overlay(deps, actor, controls, { references: overlayReferences(older) })).annotations;
+	}
+	return {
+		items,
+		next: {
+			...state,
+			paymentCursor: page.cursor,
+			paymentDone: page.done,
+			paymentPending: payments.slice(pi).map((item) => item.id),
+			transferBefore,
+			transferDone: ti === transfers.length && transferEnd
+		}
+	};
+}
+function indexedPage(deps, scope, controls, params, state, first) {
+	return Effect.gen(function* () {
+		const range = boundedRange(params?.range, state.checkpoint);
+		const wantsTransfers = params?.filter?.kind !== "payment" && params?.filter?.status === void 0;
+		const found = yield* readTransfers(deps, scope.safe, range, state, wantsTransfers, first);
+		if (found === null) return yield* unavailablePage(deps, scope, controls, params, state, first);
+		const transfers = wantsTransfers ? found : [];
+		const page = yield* readPayments(deps, scope, controls, range, state, params?.filter?.kind !== "movement");
+		const decoration = yield* decoratePage(deps, scope, controls, transfers, page, range);
+		if (decoration === null) return yield* unavailablePage(deps, scope, controls, params, state, first);
+		const { items, next } = mergePage(scope.safe, params?.filter, params?.limit ?? 25, state, page, decoration, transfers, wantsTransfers);
+		const cursor = next.paymentDone && next.paymentPending.length === 0 && next.transferDone ? null : JSON.stringify(next);
+		if (cursor !== null && cursor === params?.cursor) return yield* Effect.fail({ publicError: Errors.invalidInput("cursor", "Activity source did not advance") });
+		yield* Effect.annotateCurrentSpan({ read_source: "indexer" });
 		return {
-			items: stitchActivity({
-				safe: scope.safe,
-				transfers: rows.transfers,
-				payments: rows.payments,
-				intents,
-				links: decoration.links,
-				annotations: [...decoration.annotations, ...olderDecoration]
-			}).filter((item) => inRange(item, params.range) && matchesFilter(item, params.filter)),
-			stitched: true
+			items,
+			cursor,
+			checkpoint: state.checkpoint,
+			observedAt: Date.now()
 		};
 	});
 }
 function readActivityPage(deps, actor, controls, params) {
-	const limit = params?.limit ?? 25;
-	const offset = parseCursor(params?.cursor);
-	return stitchedWindow(deps, actor, controls, offset + limit + 1, {
-		...params?.range === void 0 ? {} : { range: params.range },
-		...params?.filter === void 0 ? {} : { filter: params.filter }
-	}).pipe(Effect.map(({ items, stitched, readWarning }) => {
-		const observedAt = Date.now();
-		if (!stitched) return {
-			items: items.slice(0, limit),
+	return Effect.gen(function* () {
+		yield* Effect.try({
+			try: () => requireParams(params),
+			catch: (cause) => ({ publicError: cause })
+		});
+		const scope = yield* overlay(deps, actor, controls, {});
+		const selection = selectionKey(params);
+		const cursor = yield* Effect.try({
+			try: () => parseCursor(params?.cursor, scopeKey(scope), selection),
+			catch: () => ({ publicError: Errors.invalidInput("cursor", "invalid or obsolete Activity cursor; restart the read") })
+		});
+		const state = cursor ?? {
+			version: 1,
+			scope: scopeKey(scope),
+			selection,
+			checkpoint: Date.now(),
+			source: "indexed",
+			paymentCursor: null,
+			paymentDone: false,
+			paymentPending: [],
+			transferBefore: null,
+			transferDone: false,
+			degraded: false
+		};
+		const range = boundedRange(params?.range, state.checkpoint);
+		if (range.from !== void 0 && range.from > range.to) return {
+			items: [],
 			cursor: null,
-			checkpoint: observedAt,
-			observedAt,
-			...readWarning === void 0 ? {} : { readWarning }
+			checkpoint: state.checkpoint,
+			observedAt: Date.now()
 		};
+		if (state.source === "fallback" || scope.safe === null) return yield* fallbackPage(deps, scope, controls, params, state, state.degraded);
+		if (scope.payments === void 0) return yield* unavailablePage(deps, scope, controls, params, state, cursor === null);
+		return yield* indexedPage(deps, scope, controls, params, state, cursor === null);
+	});
+}
+function readActivitySummary(deps, actor, controls, params) {
+	return Effect.gen(function* () {
+		const totals = /* @__PURE__ */ new Map();
+		let cursor;
+		let count = 0;
+		let readWarning;
+		do {
+			const page = yield* readActivityPage(deps, actor, controls, {
+				limit: BATCH,
+				...cursor === void 0 ? {} : { cursor },
+				...params?.window === void 0 ? {} : { range: params.window }
+			});
+			count += page.items.length;
+			readWarning ??= page.readWarning;
+			for (const total of summarizeItems(page.items)) {
+				const key = `${total.currency}:${total.decimals}`;
+				const old = totals.get(key);
+				totals.set(key, old === void 0 ? total : {
+					...total,
+					in: String(BigInt(old.in) + BigInt(total.in)),
+					out: String(BigInt(old.out) + BigInt(total.out)),
+					net: String(BigInt(old.net) + BigInt(total.net)),
+					pendingIn: String(BigInt(old.pendingIn) + BigInt(total.pendingIn))
+				});
+			}
+			cursor = page.cursor ?? void 0;
+		} while (cursor !== void 0);
 		return {
-			items: items.slice(offset, offset + limit),
-			cursor: items.length > offset + limit ? JSON.stringify({ offset: offset + limit }) : null,
-			checkpoint: observedAt,
-			observedAt
+			window: {
+				from: params?.window?.from ?? null,
+				to: params?.window?.to ?? null
+			},
+			totals: [...totals.values()],
+			count,
+			observedAt: Date.now(),
+			...readWarning === void 0 ? {} : { readWarning }
 		};
-	}));
+	});
 }
-function readActivitySummary(deps, actor, controls, params) {
-	return stitchedWindow(deps, actor, controls, SUMMARY_WINDOW, params?.window === void 0 ? {} : { range: params.window }).pipe(Effect.map(({ items, readWarning }) => ({
-		window: {
-			from: params?.window?.from ?? null,
-			to: params?.window?.to ?? null
-		},
-		totals: summarizeItems(items),
-		count: items.length,
-		observedAt: Date.now(),
-		...readWarning === void 0 ? {} : { readWarning }
-	})));
+/** An indexed Movement has no Convex materialization. Read its exact native row. */
+function readIndexedMovement(deps, actor, controls, eventId) {
+	return Effect.gen(function* () {
+		const scope = yield* overlay(deps, actor, controls, { references: [{
+			kind: "movement",
+			id: eventId
+		}] });
+		if (scope.safe === null) return null;
+		const safe = scope.safe.toLowerCase();
+		const row = (yield* deps.indexer.read("transfer", {
+			safe: toAddress(safe),
+			limit: 1,
+			eventId
+		}).pipe(Effect.catch((error) => Effect.fail({ publicError: error.publicError }))))[0];
+		if (row === void 0) return null;
+		const blockNumber = Number(row.blockNumber);
+		if (row.id !== eventId || row.from.toLowerCase() !== safe && row.to.toLowerCase() !== safe || !Number.isSafeInteger(blockNumber) || blockNumber < 0 || !Number.isSafeInteger(row.logIndex) || row.logIndex < 0) return yield* Effect.fail({ publicError: Errors.invalidInput("activity", "indexed Movement does not match the requested scope or evidence") });
+		yield* Effect.annotateCurrentSpan({ read_source: "indexer" });
+		return {
+			kind: "movement",
+			movementId: row.id,
+			viewer: scope.actor,
+			annotation: scope.annotations.find((annotation) => annotation.reference.kind === "movement" && annotation.reference.id === row.id) ?? null,
+			evidence: {
+				chainId: row.chainId,
+				contractAddress: row.token,
+				tokenAddress: row.token,
+				transactionHash: row.txHash,
+				blockNumber,
+				blockHash: row.blockHash,
+				inclusion: "included",
+				verification: "verified",
+				canonicalState: "finalized",
+				transferLogIndex: row.logIndex,
+				source: row.from,
+				destination: row.to,
+				rawAmount: row.amount.toString(),
+				link: {
+					movementId: row.id,
+					depositPaymentId: null
+				}
+			}
+		};
+	});
 }
-/**
-* Tell the caller when the indexed page for this Safe changed.
-*
-* The transport is the indexer's one SSE connection, wired in the Ponder
-* adapter under `activity.subscribe`. A reactive snapshot is not a product
-* event, so nothing here emits telemetry: the adapter reports a teardown, and
-* the caller re-reads.
-*/
 function subscribeActivity(deps, actor, controls, onChange) {
 	return Effect.gen(function* () {
 		const scope = yield* overlay(deps, actor, controls, {});
 		if (scope.safe === null) return () => {};
-		const page = {
-			safe: scope.safe,
-			limit: INTENT_WINDOW
-		};
 		let delivered = false;
-		const notify = () => {
-			if (delivered) onChange();
-			delivered = true;
-		};
-		return yield* deps.indexer.subscribe("transfer", page, (snapshot) => {
-			if (snapshot.status === "ok") notify();
+		return yield* deps.indexer.subscribe("transfer", {
+			safe: toAddress(scope.safe),
+			limit: BATCH
+		}, (snapshot) => {
+			if (snapshot.status === "ok") {
+				if (delivered) onChange();
+				delivered = true;
+			}
 			if (snapshot.status === "error") {
 				delivered = true;
 				onChange();
@@ -11493,7 +11693,7 @@ function subscribeActivity(deps, actor, controls, onChange) {
 }
 //#endregion
 //#region ../../packages/sdk/package.json
-var version$1 = "4.20.0-beta.1";
+var version$1 = "4.20.0-beta.2";
 //#endregion
 //#region ../../packages/sdk/src/telemetry/exception-projection.ts
 /** Fixed fallback for failures that have no safe message. */
@@ -13059,7 +13259,10 @@ function makeFinancialOpsMethods(deps) {
 					...params?.limit === void 0 ? {} : { limit: params.limit },
 					...params?.range === void 0 ? {} : { range: params.range },
 					...params?.filter === void 0 ? {} : { filter: params.filter }
-				} })) : readActivityPage(indexerDeps, actor, controls, params)).pipe(Effect.tap(() => observeActivityScope(actor))))), controls, CAPXUL_OPERATIONS.activity.list, deps.runPromise);
+				} })) : readActivityPage(indexerDeps, actor, controls, params)).pipe(Effect.map((page) => ({
+					...page,
+					items: page.items.filter(isActivityVisible)
+				})), Effect.tap(() => observeActivityScope(actor))))), controls, CAPXUL_OPERATIONS.activity.list, deps.runPromise);
 			},
 			summary: (params, options) => {
 				const controls = deps.invocationControls?.(options) ?? options;
@@ -13080,7 +13283,10 @@ function makeFinancialOpsMethods(deps) {
 						actor: scope,
 						referenceActor: reference.kind === "payment" ? activityActorField(reference.actor).actor : void 0
 					});
-				}).pipe(Effect.flatMap(({ actor, referenceActor }) => Effect.suspend(() => deps.convexCall.query(fns.activityGet, copyInvocationObservation(controls, {
+				}).pipe(Effect.flatMap(({ actor, referenceActor }) => Effect.suspend(() => indexerDeps !== void 0 && reference.kind === "movement" && /^[1-9][0-9]{0,9}:0x[0-9a-f]{64}:[0-9]{1,10}$/.test(reference.id) ? readIndexedMovement(indexerDeps, actor?.kind === "org" ? {
+					kind: "organization",
+					orgId: actor.orgId
+				} : void 0, controls, reference.id) : deps.convexCall.query(fns.activityGet, copyInvocationObservation(controls, {
 					input: {
 						kind: reference.kind,
 						id: reference.id,
@@ -47668,7 +47874,8 @@ function decodeTransfer(value) {
 		token: toAddress(hex(row, "token")),
 		from: toAddress(hex(row, "from")),
 		to: toAddress(hex(row, "to")),
-		amount: big(row, "amount")
+		amount: big(row, "amount"),
+		..."payment_settlement_id" in row ? { paymentSettlementId: row.payment_settlement_id === null ? null : hex(row, "payment_settlement_id") } : {}
 	};
 }
 function decodePayment(value) {
@@ -47754,6 +47961,60 @@ const ACTOR_PARAMS = {
 */
 function ponderQuery(table, input) {
 	const safe = assertIndexerPage(input);
+	if (input.eventId !== void 0) {
+		if (table !== "transfer") throw Errors.invalidInput("eventId", "only transfer reads accept a logical event ID");
+		return {
+			sql: `${HEADS.transfer.slice(0, HEADS.transfer.indexOf(" from \"transfer\""))} from "transfer" where (("transfer"."from" = $1 or "transfer"."to" = $2) and "transfer"."id" = $3) limit $4`,
+			params: [
+				safe,
+				safe,
+				input.eventId,
+				1
+			],
+			typings: [
+				"none",
+				"none",
+				"none",
+				"none"
+			]
+		};
+	}
+	if (input.settlements !== void 0) {
+		if (table !== "payment") throw Errors.invalidInput("settlements", "only Payment reads accept settlement IDs");
+		const params = [
+			safe,
+			safe,
+			...input.settlements,
+			input.limit
+		];
+		return {
+			sql: `${HEADS.payment.slice(0, HEADS.payment.indexOf("where "))}where (("payment"."sender" = $1 or "payment"."recipient" = $2) and "payment"."settlement_id" in (${input.settlements.map((_, i) => `$${i + 3}`).join(", ")})) limit $${params.length}`,
+			params,
+			typings: params.map(() => "none")
+		};
+	}
+	if (input.timeline !== void 0) {
+		if (table !== "transfer") throw Errors.invalidInput("timeline", "only transfer reads have a timeline");
+		const { from, to, before } = input.timeline;
+		const params = [
+			safe,
+			safe,
+			from,
+			to
+		];
+		const select = HEADS.transfer.slice(0, HEADS.transfer.indexOf(" from \"transfer\"")) + ", \"payment_settlement_id\" from \"activity_transfer\" ";
+		let where = "(\"activity_transfer\".\"from\" = $1 or \"activity_transfer\".\"to\" = $2) and \"activity_transfer\".\"timestamp\" >= $3 and \"activity_transfer\".\"timestamp\" <= $4";
+		if (before !== void 0) {
+			params.push(before.timestamp, before.timestamp, before.id);
+			where += " and (\"activity_transfer\".\"timestamp\" < $5 or (\"activity_transfer\".\"timestamp\" = $6 and \"activity_transfer\".\"id\" < $7))";
+		}
+		params.push(input.limit);
+		return {
+			sql: `${select}where (${where}) order by "activity_transfer"."timestamp" desc, "activity_transfer"."id" desc limit $${params.length}`,
+			params,
+			typings: params.map(() => "none")
+		};
+	}
 	const offset = input.offset ?? 0;
 	const actors = ACTOR_PARAMS[table];
 	const params = [];
@@ -49496,8 +49757,8 @@ function renderResult(mode, envelope, lines = []) {
 }
 //#endregion
 //#region src/version.ts
-const cliVersion = "4.20.0-beta.1";
-const sdkVersion = "4.20.0-beta.1";
+const cliVersion = "4.20.0-beta.2";
+const sdkVersion = "4.20.0-beta.2";
 //#endregion
 //#region src/runtime/run-command.ts
 var CliRuntime = class extends Context.Service()("capxul-cli/Runtime") {};