@capxul/sdk-react 2.3.2 → 2.5.0

package/dist/index.mjs

@@ -1,8 +1,8 @@
 "use client";
-import { a as useCapxulAuth, c as useCapxulIdentityOrNull, d as capxulKeys, f as useCapxulClientOrNull, i as entered, l as useCapxulSend, n as CapxulOnboardingController, o as useCapxulDestination, p as useCapxul, r as CapxulProvider, s as useCapxulIdentity, t as CapxulAuthenticationController, u as useCapxulTransitions } from "./controllers-VwUPB619.mjs";
+import { a as useCapxulAuth, c as useCapxulIdentityOrNull, d as capxulKeys, f as useCapxulClientOrNull, i as entered, l as useCapxulSend, n as CapxulOnboardingController, o as useCapxulDestination, p as useCapxul, r as CapxulProvider, s as useCapxulIdentity, t as CapxulAuthenticationController, u as useCapxulTransitions } from "./controllers-BJ_uFXT3.mjs";
 import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
-import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
-import { CapxulError, Errors, fingerprintPaymentIntent, formatMoney, isClaimed, isClaimed as isClaimed$1, isMoneyParseError, isRestoring, isRestoring as isRestoring$1, parseMoney, resolveIdentityDestination } from "@capxul/sdk";
+import { useInfiniteQuery, useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { CapxulError, Errors, PAYMENT_DIRECTIONS, PAYMENT_STATUSES, fingerprintPaymentIntent, formatMoney, isCapxulError, isClaimed, isClaimed as isClaimed$1, isMoneyParseError, isRestoring, isRestoring as isRestoring$1, parseMoney, paymentPhase, resolveIdentityDestination } from "@capxul/sdk";
 import { Fragment, jsx } from "react/jsx-runtime";
 //#region src/internal/require-bootstrapped-client.ts
 /**
@@ -429,14 +429,14 @@ function useCapxulActivity(params) {
 		enabled: client !== null && identity !== null && isClaimed$1(identity)
 	});
 }
-function useCapxulActivityDetail(reference) {
+function useCapxulActivityDetail(reference, actor) {
 	const client = useCapxulClientOrNull();
 	const identity = useCapxulIdentityOrNull();
 	return useQuery({
-		queryKey: capxulKeys.activityDetail(reference),
+		queryKey: capxulKeys.activityDetail(reference, actor),
 		queryFn: async () => {
 			if (reference === void 0) throw Errors.invalidInput("reference", "required for activity.get");
-			return unwrapCapxulResult(await requireBootstrappedClient(client, "activity.get").activity.get(reference));
+			return unwrapCapxulResult(await requireBootstrappedClient(client, "activity.get").activity.get(reference, actor === void 0 ? void 0 : { actor }));
 		},
 		enabled: client !== null && reference !== void 0 && identity !== null && isClaimed$1(identity)
 	});
@@ -453,13 +453,14 @@ function useCapxulAnnotateMovement() {
 }
 //#endregion
 //#region src/hooks/use-capxul-holdings.ts
-function useCapxulHoldings() {
+function useCapxulHoldings(params) {
 	const client = useCapxulClientOrNull();
 	const identity = useCapxulIdentityOrNull();
+	const actor = params?.actor;
 	return useQuery({
-		queryKey: capxulKeys.holdings,
+		queryKey: capxulKeys.holdings(actor),
 		queryFn: async () => {
-			return unwrapCapxulResult(await requireBootstrappedClient(client, "holdings.current").holdings.current());
+			return unwrapCapxulResult(await requireBootstrappedClient(client, "holdings.current").holdings.current(actor === void 0 ? void 0 : { actor }));
 		},
 		enabled: client !== null && identity !== null && isClaimed$1(identity)
 	});
@@ -1013,7 +1014,7 @@ function useContactsContext() {
 	if (engine === null) throw new Error("CapxulContacts parts must be used inside <CapxulContacts>");
 	return engine;
 }
-function Root$3({ actor, onAdded, onFailed, children }) {
+function Root$6({ actor, onAdded, onFailed, children }) {
 	const engine = useContacts({
 		actor,
 		onAdded,
@@ -1024,7 +1025,7 @@ function Root$3({ actor, onAdded, onFailed, children }) {
 		children
 	});
 }
-function Summary({ children }) {
+function Summary$3({ children }) {
 	return /* @__PURE__ */ jsx(Fragment, { children: children(useContactsSummary(useContactsContext())) });
 }
 function List({ limit, show, children }) {
@@ -1037,12 +1038,674 @@ function Add({ children }) {
 	return /* @__PURE__ */ jsx(Fragment, { children: children(useContactsContext().add) });
 }
 /** The compound shape the app's own design system already uses (`StatusTabs`). */
-const CapxulContacts = Object.assign(Root$3, {
-	Summary,
+const CapxulContacts = Object.assign(Root$6, {
+	Summary: Summary$3,
 	List,
 	Add
 });
 //#endregion
+//#region src/internal/as-capxul-error.ts
+/**
+* TanStack types a query error as `Error`. Every query in this package throws
+* through `unwrapCapxulResult` or `requireBootstrappedClient`, so the value IS a
+* `CapxulError`. Anything else is a defect inside this package: it is WRAPPED
+* with the `UNKNOWN` code and its cause, never swallowed, because a slice hands
+* the app an error VALUE carrying a code and the app writes the sentence
+* (ADR-0023).
+*/
+function asCapxulError$1(error) {
+	if (error === null) return null;
+	return isCapxulError(error) ? error : Errors.unknown(error);
+}
+//#endregion
+//#region src/headless/activity/enabled.ts
+/**
+* The one gate every read under `CapxulActivity` shares — the engine, each
+* `.Summary` lane, and each `.Detail` lane. One function, because a gate that
+* differs between the list and the detail lets a screen load rows it can never
+* open.
+*
+* Every backend activity read resolves the authenticated Account before it
+* resolves either a personal or Organization actor. Wait for that Account so a
+* new session cannot issue requests the backend must refuse.
+*/
+function useActivityEnabled() {
+	const client = useCapxulClientOrNull();
+	const identity = useCapxulIdentityOrNull();
+	return client !== null && identity !== null && isClaimed$1(identity);
+}
+//#endregion
+//#region src/headless/activity/detail.ts
+/**
+* ONE finished document, never the array, so no consumer writes `documents[0]`:
+* the payslip, else the receipt, else nothing. Those two kinds are the ones the
+* Download receipt button is for. A Movement detail carries no documents.
+*/
+function pickReceiptDocument(detail) {
+	if (detail === null || detail.kind !== "payment") return null;
+	const documents = detail.payment.documents;
+	return documents.find((document) => document.kind === "payslip") ?? documents.find((document) => document.kind === "receipt") ?? null;
+}
+/**
+* The root actor and the whole reference are included. A payment reference can
+* carry its own actor, and a Movement reference relies on the root actor. A key
+* of kind and id alone would show one actor's draft memo on the other actor's
+* row, and save it there.
+*
+* The parts go into an ARRAY, and the array is what gets serialized. A joined
+* string collides: an organization whose id is the sentinel `self`, or any id
+* that carries the separator, produces another reference's key. Serializing the
+* reference OBJECT collides the other way, because property order is not part of
+* a reference's meaning and a literal written `{ id, kind }` must not read as a
+* different row. The array is ordered here, by this function, so neither the
+* caller's property order nor the content of an id can move a part.
+*/
+function actorKey(actor) {
+	if (actor === void 0) return null;
+	return actor.kind === "organization" ? [actor.kind, actor.organizationId] : [actor.kind];
+}
+function activityDetailKey(actor, reference) {
+	if (reference === void 0) return JSON.stringify([actorKey(actor), null]);
+	const referenceActor = reference.kind === "payment" ? reference.actor : void 0;
+	return JSON.stringify([actorKey(actor), [
+		reference.kind,
+		reference.id,
+		actorKey(referenceActor)
+	]]);
+}
+function useActivityDetail(reference, actor) {
+	const client = useCapxulClientOrNull();
+	const enabled = useActivityEnabled() && reference !== void 0;
+	const detail = useQuery({
+		queryKey: capxulKeys.activityDetail(reference, actor),
+		queryFn: async () => {
+			if (reference === void 0) throw Errors.invalidInput("reference", "required for activity.get");
+			return unwrapCapxulResult(await requireBootstrappedClient(client, "activity.get").activity.get(reference, actor === void 0 ? void 0 : { actor }));
+		},
+		enabled
+	});
+	const receiptDocument = pickReceiptDocument(detail.data ?? null);
+	const [isOpeningDocument, setIsOpeningDocument] = useState(false);
+	const openReceiptDocument = useCallback(async () => {
+		if (reference === void 0 || receiptDocument === null) throw Errors.invalidInput("receiptDocument", "no renderable document on this row");
+		setIsOpeningDocument(true);
+		try {
+			return unwrapCapxulResult(await requireBootstrappedClient(client, "paymentDocuments.render").paymentDocuments.render(receiptDocument.documentHash));
+		} finally {
+			setIsOpeningDocument(false);
+		}
+	}, [
+		client,
+		receiptDocument,
+		reference
+	]);
+	const [typed, setTyped] = useState(null);
+	const annotate = useCapxulAnnotateMovement();
+	const saveMemo = useCallback(() => {
+		if (reference === void 0 || typed === null) return;
+		annotate.mutate({
+			...actor === void 0 ? {} : { actor },
+			reference,
+			memo: typed
+		});
+	}, [
+		actor,
+		annotate,
+		reference,
+		typed
+	]);
+	return {
+		receiptDocument,
+		openReceiptDocument,
+		isOpeningDocument,
+		memo: typed ?? detail.data?.annotation?.memo ?? "",
+		setMemo: setTyped,
+		saveMemo,
+		isSavingMemo: annotate.isPending,
+		isLoading: enabled && detail.isLoading,
+		error: asCapxulError$1(detail.error) ?? annotate.error ?? null
+	};
+}
+//#endregion
+//#region src/headless/activity/summary.ts
+const DAY_MS = 864e5;
+/**
+* `"last30days"` is the last 30 whole UTC days including today. Quantizing to
+* the UTC day keeps the cache key stable for a whole day instead of changing on
+* every render.
+*/
+function resolveWindow(window, now) {
+	if (window === "all") return void 0;
+	if (window === "last30days") return { from: Math.floor(now / DAY_MS) * DAY_MS - 29 * DAY_MS };
+	return window;
+}
+/** An integer raw-unit string lifted into a major-unit decimal string. */
+function majorUnits(raw, decimals) {
+	const negative = raw.startsWith("-");
+	const digits = negative ? raw.slice(1) : raw;
+	const sign = negative ? "-" : "";
+	if (decimals === 0) return `${sign}${digits}`;
+	const padded = digits.padStart(decimals + 1, "0");
+	const cut = padded.length - decimals;
+	return `${sign}${padded.slice(0, cut)}.${padded.slice(cut)}`;
+}
+function absoluteNet(total) {
+	const net = BigInt(total.net);
+	return net < 0n ? -net : net;
+}
+/**
+* Buckets carry different `decimals`, so their raw integers are not comparable.
+* Both are scaled to the wider precision before the magnitudes are ordered.
+*/
+function compareNet(left, right) {
+	const width = Math.max(left.decimals, right.decimals);
+	const scaledLeft = absoluteNet(left) * 10n ** BigInt(width - left.decimals);
+	const scaledRight = absoluteNet(right) * 10n ** BigInt(width - right.decimals);
+	if (scaledLeft === scaledRight) return 0;
+	return scaledLeft < scaledRight ? -1 : 1;
+}
+/**
+* Which currency `.Summary` shows: the bucket matching the primary holding's
+* currency, else the bucket with the largest absolute `net`, breaking a tie on
+* currency code ascending so the choice is stable across reloads.
+*
+* The primary holding is matched on `available.currency` — the consumer
+* `CurrencyCode` — and NOT on `Holding.symbol`, which is the raw token ticker
+* ("USDX") and can never equal a bucket's currency ("USD"). See the contract
+* correction on #1449.
+*/
+function pickBucket(totals, primaryCurrency) {
+	if (primaryCurrency !== null) {
+		const matched = totals.find((total) => total.currency === primaryCurrency);
+		if (matched !== void 0) return matched;
+	}
+	let best = null;
+	for (const total of totals) {
+		if (best === null) {
+			best = total;
+			continue;
+		}
+		const order = compareNet(total, best);
+		if (order > 0 || order === 0 && total.currency < best.currency) best = total;
+	}
+	return best;
+}
+/**
+* The current UTC day number, which advances ON ITS OWN at UTC midnight.
+*
+* The day is NOT held in state. It is read at every render, so it can never be
+* stale — not after a mount that sat through midnight, and not when a part
+* mounted on a fixed window is later switched to a rolling one. State holds
+* only `tick`, whose single job is to force the render that a screen sitting
+* idle would otherwise never do: React recomputes nothing on its own, so an
+* untouched summary would hold yesterday's boundary indefinitely.
+*
+* The effect depends on `tick`, not on the day, so the timer re-arms whatever
+* the clock says when it fires. A wake a millisecond early re-arms for the
+* boundary still ahead instead of silently ending the rollover, and a wake
+* hours late — a throttled tab, a sleeping machine — lands on the true day
+* rather than drifting one day per sleep.
+*
+* `active` is false for the windows that do not roll, so a fixed window arms no
+* timer at all.
+*/
+function useUtcDay(active) {
+	const [tick, setTick] = useState(0);
+	useEffect(() => {
+		if (!active) return;
+		const timer = setTimeout(() => {
+			setTick((value) => value + 1);
+		}, DAY_MS - Date.now() % DAY_MS + 1);
+		return () => {
+			clearTimeout(timer);
+		};
+	}, [active, tick]);
+	return Math.floor(Date.now() / DAY_MS);
+}
+function useActivitySummary(actor, window) {
+	const client = useCapxulClientOrNull();
+	const enabled = useActivityEnabled();
+	const range = resolveWindow(window, useUtcDay(window === "last30days") * DAY_MS);
+	const summary = useQuery({
+		queryKey: capxulKeys.activitySummary(actor, range),
+		queryFn: async () => {
+			const params = {};
+			if (actor !== void 0) params.actor = actor;
+			if (range !== void 0) params.window = range;
+			return unwrapCapxulResult(await requireBootstrappedClient(client, "activity.summary").activity.summary(params));
+		},
+		enabled
+	});
+	const primary = useQuery({
+		queryKey: [...capxulKeys.holdings(actor), "primary"],
+		queryFn: async () => {
+			return unwrapCapxulResult(await requireBootstrappedClient(client, "holdings.primary").holdings.primary(actor === void 0 ? void 0 : { actor }));
+		},
+		enabled
+	});
+	const totals = summary.data?.totals;
+	const primaryCurrency = primary.data?.available.currency ?? null;
+	const isLoading = summary.isLoading || primary.isLoading;
+	const bucket = useMemo(() => totals === void 0 || isLoading ? null : pickBucket(totals, primaryCurrency), [
+		isLoading,
+		primaryCurrency,
+		totals
+	]);
+	if (bucket === null) return {
+		currency: null,
+		moneyIn: null,
+		moneyOut: null,
+		net: null,
+		pending: null,
+		count: summary.data?.count ?? 0,
+		isLoading,
+		error: asCapxulError$1(summary.error)
+	};
+	const display = (raw) => formatMoney({
+		currency: bucket.currency,
+		value: majorUnits(raw, bucket.decimals),
+		decimals: bucket.decimals
+	});
+	return {
+		currency: bucket.currency,
+		moneyIn: display(bucket.in),
+		moneyOut: display(bucket.out),
+		net: display(bucket.net),
+		pending: display(bucket.pendingIn),
+		count: summary.data?.count ?? 0,
+		isLoading,
+		error: asCapxulError$1(summary.error)
+	};
+}
+//#endregion
+//#region src/headless/activity/rows.ts
+/**
+* A Movement's phase is DERIVED, not asserted: `movementItems` returns `null`
+* for any Movement whose `canonicalState` is not `"finalized"`
+* (`activityList.ts:120`), so a Movement that reaches a page is finished and
+* carries no verdict of its own.
+*/
+const MOVEMENT_PHASE = Object.freeze({
+	terminal: true,
+	outcome: "neutral",
+	needsAction: false
+});
+/** The sign grammar of the app's `formatDirectionalAmount` — unsigned for `self`. */
+const SIGN = Object.freeze({
+	in: "+",
+	out: "-",
+	self: ""
+});
+function toActivityRow(item, actor) {
+	const amountDisplay = formatMoney(item.amount);
+	const signedAmountDisplay = `${SIGN[item.direction]}${amountDisplay}`;
+	if (item.kind === "movement") return {
+		kind: "movement",
+		reference: {
+			kind: "movement",
+			id: item.id
+		},
+		direction: item.direction,
+		counterpartyLabel: item.counterpartyLabel,
+		amountDisplay,
+		signedAmountDisplay,
+		currency: item.amount.currency,
+		createdAt: item.createdAt,
+		classification: item.classification,
+		phase: MOVEMENT_PHASE,
+		receipt: item.receipt
+	};
+	return {
+		kind: "payment",
+		reference: actor === void 0 ? {
+			kind: "payment",
+			id: item.id
+		} : {
+			kind: "payment",
+			id: item.id,
+			actor
+		},
+		direction: item.direction,
+		counterpartyLabel: item.counterpartyLabel,
+		amountDisplay,
+		signedAmountDisplay,
+		currency: item.amount.currency,
+		createdAt: item.createdAt,
+		ledgerKind: item.ledgerKind,
+		paymentType: item.paymentType,
+		status: item.status,
+		phase: paymentPhase(item.status),
+		receipt: item.receipt
+	};
+}
+/**
+* The exact field set `.Search` matches, case-insensitively, joined with a
+* space. Two of today's searchable strings drop out on purpose: `account` is
+* the currency-to-name guess this item deletes, and `statusLabel` is app copy —
+* the Status dropdown, wired up in the same change, is the affordance for
+* filtering by status and it uses the app's own words.
+*/
+function searchableText(row) {
+	return (row.kind === "payment" ? [
+		row.counterpartyLabel,
+		row.amountDisplay,
+		row.status,
+		row.paymentType,
+		row.ledgerKind
+	] : [
+		row.counterpartyLabel,
+		row.amountDisplay,
+		row.classification
+	]).join(" ").toLowerCase();
+}
+function matchesSearch(row, query) {
+	const needle = query.trim().toLowerCase();
+	return needle === "" || searchableText(row).includes(needle);
+}
+//#endregion
+//#region src/headless/activity/csv.ts
+/** In this order. A header row is always written, even with no rows. */
+const COLUMNS = [
+	"Date",
+	"Kind",
+	"Type",
+	"Counterparty",
+	"Direction",
+	"Amount",
+	"Currency",
+	"Status",
+	"Reference",
+	"Transaction hash"
+];
+const FORMULA_LEAD = /^[=+\-@\t\r\n]/;
+const PLAIN_NUMBER = /^-?\d+(\.\d+)?$/;
+/**
+* RFC 4180: every field is quoted, and an embedded quote is doubled. A field
+* that would open a formula is first prefixed with an apostrophe, which the
+* spreadsheet consumes and renders as text.
+*/
+function escape(field) {
+	return `"${(FORMULA_LEAD.test(field) && !PLAIN_NUMBER.test(field) ? `'${field}` : field).replaceAll("\"", "\"\"")}"`;
+}
+function record(fields) {
+	return fields.map(escape).join(",");
+}
+/**
+* `Amount` is the major-unit decimal value, not the display string, because a
+* CSV is data and the sheet has its own `Currency` column to pair it with. The
+* sign lives in `Direction`, which is the code the row carries.
+*/
+function buildCsv(items, actor, search) {
+	const records = [record(COLUMNS)];
+	for (const item of items) {
+		const row = toActivityRow(item, actor);
+		if (!matchesSearch(row, search)) continue;
+		records.push(record([
+			new Date(row.createdAt).toISOString(),
+			row.kind,
+			row.kind === "payment" ? row.paymentType : row.classification,
+			row.counterpartyLabel,
+			row.direction,
+			item.amount.value,
+			item.amount.currency,
+			row.kind === "payment" ? row.status : "",
+			row.reference.id,
+			row.receipt?.transactionHash ?? ""
+		]));
+	}
+	return {
+		text: records.join("\r\n"),
+		rowCount: records.length - 1
+	};
+}
+//#endregion
+//#region src/headless/activity/use-activity.ts
+/** The band is the backend's own — it hard-rejects a limit outside it. */
+const MIN_PAGE_SIZE = 1;
+const MAX_PAGE_SIZE = 100;
+const DEFAULT_PAGE_SIZE = 25;
+/**
+* The export ceiling is HARD: 50 pages of 100 is at most 5,000 rows. An
+* unbounded `do…while (cursor)` drain is the exact defect this item deletes
+* from the app; re-creating it inside the SDK would move the bug, not fix it.
+*/
+const EXPORT_PAGE_SIZE = MAX_PAGE_SIZE;
+const EXPORT_PAGE_CEILING = 50;
+const KIND_OPTIONS = Object.freeze(["payment", "movement"]);
+/** Clamps into 1..100. A non-number, or a fraction, lands on the default band. */
+function clampPageSize(pageSize) {
+	if (pageSize === void 0 || !Number.isFinite(pageSize)) return DEFAULT_PAGE_SIZE;
+	return Math.min(MAX_PAGE_SIZE, Math.max(MIN_PAGE_SIZE, Math.trunc(pageSize)));
+}
+function useActivity(input) {
+	const { actor, pageSize } = input;
+	const client = useCapxulClientOrNull();
+	const enabled = useActivityEnabled();
+	const limit = clampPageSize(pageSize);
+	const warned = useRef(false);
+	useEffect(() => {
+		if (warned.current || pageSize === void 0 || pageSize === limit) return;
+		warned.current = true;
+		if (process.env.NODE_ENV !== "production") console.warn(`CapxulActivity: pageSize ${String(pageSize)} is outside 1..100 and was clamped to ${String(limit)}.`);
+	}, [limit, pageSize]);
+	const [kind, setKind] = useState(void 0);
+	const [direction, setDirection] = useState(void 0);
+	const [status, setStatus] = useState([]);
+	const [searchText, setSearchText] = useState("");
+	const values = useMemo(() => ({
+		...kind === void 0 ? {} : { kind },
+		...direction === void 0 ? {} : { direction },
+		...status.length === 0 ? {} : { status }
+	}), [
+		direction,
+		kind,
+		status
+	]);
+	const filter = useMemo(() => Object.keys(values).length === 0 ? void 0 : values, [values]);
+	const listParams = useCallback((cursor, pageLimit) => {
+		const params = { limit: pageLimit };
+		if (actor !== void 0) params.actor = actor;
+		if (cursor !== void 0) params.cursor = cursor;
+		if (filter !== void 0) params.filter = filter;
+		return params;
+	}, [actor, filter]);
+	const query = useInfiniteQuery({
+		queryKey: [
+			...capxulKeys.activity,
+			"list",
+			actor ?? "self",
+			limit,
+			filter ?? "none"
+		],
+		queryFn: async ({ pageParam }) => {
+			return unwrapCapxulResult(await requireBootstrappedClient(client, "activity.list").activity.list(listParams(pageParam, limit)));
+		},
+		initialPageParam: void 0,
+		getNextPageParam: (last) => last.cursor ?? void 0,
+		enabled
+	});
+	const pages = query.data?.pages;
+	const rows = useMemo(() => {
+		return (pages?.flatMap((page) => page.items) ?? []).map((item) => toActivityRow(item, actor)).filter((row) => matchesSearch(row, searchText));
+	}, [
+		actor,
+		pages,
+		searchText
+	]);
+	const { fetchNextPage, hasNextPage, isFetchingNextPage, refetch } = query;
+	const pagingRef = useRef({
+		fetchNextPage,
+		hasNextPage,
+		isFetchingNextPage
+	});
+	useEffect(() => {
+		pagingRef.current = {
+			fetchNextPage,
+			hasNextPage,
+			isFetchingNextPage
+		};
+	});
+	const loadMore = useCallback(() => {
+		const paging = pagingRef.current;
+		if (!paging.hasNextPage || paging.isFetchingNextPage) return;
+		paging.fetchNextPage();
+	}, []);
+	const observerRef = useRef(null);
+	const sentinelRef = useCallback((node) => {
+		observerRef.current?.disconnect();
+		observerRef.current = null;
+		if (node === null || typeof IntersectionObserver === "undefined") return;
+		const observer = new IntersectionObserver((entries) => {
+			if (entries.some((entry) => entry.isIntersecting)) loadMore();
+		}, {
+			root: null,
+			rootMargin: "200px",
+			threshold: 0
+		});
+		observer.observe(node);
+		observerRef.current = observer;
+	}, [loadMore]);
+	const [isExporting, setIsExporting] = useState(false);
+	const toCsv = useCallback(async () => {
+		setIsExporting(true);
+		try {
+			const bootstrapped = requireBootstrappedClient(client, "activity.list");
+			const items = [];
+			let cursor;
+			for (let page = 0; page < EXPORT_PAGE_CEILING; page += 1) {
+				const result = unwrapCapxulResult(await bootstrapped.activity.list(listParams(cursor, EXPORT_PAGE_SIZE)));
+				items.push(...result.items);
+				cursor = result.cursor ?? void 0;
+				if (cursor === void 0) break;
+			}
+			return {
+				...buildCsv(items, actor, searchText),
+				truncated: cursor !== void 0
+			};
+		} finally {
+			setIsExporting(false);
+		}
+	}, [
+		actor,
+		client,
+		listParams,
+		searchText
+	]);
+	const clear = useCallback(() => {
+		setKind(void 0);
+		setDirection(void 0);
+		setStatus([]);
+	}, []);
+	const retry = useCallback(() => {
+		refetch();
+	}, [refetch]);
+	return {
+		actor,
+		filters: {
+			values,
+			set: {
+				kind: setKind,
+				direction: setDirection,
+				status: setStatus,
+				clear
+			},
+			options: {
+				kind: KIND_OPTIONS,
+				direction: PAYMENT_DIRECTIONS,
+				status: PAYMENT_STATUSES
+			}
+		},
+		search: {
+			value: searchText,
+			change: setSearchText
+		},
+		rows: {
+			rows,
+			isLoading: query.isLoading,
+			error: asCapxulError$1(query.error),
+			retry,
+			observedAt: pages === void 0 ? null : pages[pages.length - 1]?.observedAt ?? null
+		},
+		loadMore: {
+			hasMore: hasNextPage,
+			loadMore,
+			isLoadingMore: isFetchingNextPage,
+			sentinelRef
+		},
+		csv: {
+			toCsv,
+			isExporting
+		}
+	};
+}
+//#endregion
+//#region src/headless/activity/activity.tsx
+const ActivityContext = createContext(null);
+function useActivityContext() {
+	const engine = useContext(ActivityContext);
+	if (engine === null) throw new Error("CapxulActivity parts must be used inside <CapxulActivity>");
+	return engine;
+}
+function Root$5({ actor, pageSize, children }) {
+	const engine = useActivity({
+		...actor === void 0 ? {} : { actor },
+		...pageSize === void 0 ? {} : { pageSize }
+	});
+	return /* @__PURE__ */ jsx(ActivityContext.Provider, {
+		value: engine,
+		children
+	});
+}
+/**
+* The one part that holds a query rather than reading the engine's: it takes a
+* `window` prop, and two placements can ask for different windows, so a single
+* pre-fetched result cannot serve both. It still holds no logic and draws
+* nothing.
+*/
+function Summary$2({ window = "all", children }) {
+	return /* @__PURE__ */ jsx(Fragment, { children: children(useActivitySummary(useActivityContext().actor, window)) });
+}
+function Filters({ children }) {
+	return /* @__PURE__ */ jsx(Fragment, { children: children(useActivityContext().filters) });
+}
+function Search({ children }) {
+	return /* @__PURE__ */ jsx(Fragment, { children: children(useActivityContext().search) });
+}
+function Rows({ children }) {
+	return /* @__PURE__ */ jsx(Fragment, { children: children(useActivityContext().rows) });
+}
+function LoadMore({ children }) {
+	return /* @__PURE__ */ jsx(Fragment, { children: children(useActivityContext().loadMore) });
+}
+/**
+* The second part that holds a query: it takes a `reference` prop and the root
+* has no idea which row was clicked. With no `reference` it issues no request.
+*/
+function DetailInstance({ actor, reference, children }) {
+	return /* @__PURE__ */ jsx(Fragment, { children: children(useActivityDetail(reference, actor)) });
+}
+function Detail({ reference, children }) {
+	const { actor } = useActivityContext();
+	return /* @__PURE__ */ jsx(DetailInstance, {
+		actor,
+		reference,
+		children
+	}, activityDetailKey(actor, reference));
+}
+function Export({ children }) {
+	return /* @__PURE__ */ jsx(Fragment, { children: children(useActivityContext().csv) });
+}
+/** The compound shape the app's own design system already uses (`StatusTabs`). */
+const CapxulActivity = Object.assign(Root$5, {
+	Summary: Summary$2,
+	Filters,
+	Search,
+	Rows,
+	LoadMore,
+	Detail,
+	Export
+});
+//#endregion
 //#region src/headless/send-money/signer-status.ts
 const NO_SUBSCRIPTION = () => () => {};
 function useSignerStatus(client) {
@@ -1205,7 +1868,7 @@ function useSendMoneyContext() {
 	if (engine === null) throw new Error("CapxulSendMoney parts must be used inside <CapxulSendMoney>");
 	return engine;
 }
-function Root$2({ actor, onSent, onFailed, children }) {
+function Root$4({ actor, onSent, onFailed, children }) {
 	const engine = useSendMoney({
 		actor,
 		onSent,
@@ -1216,7 +1879,7 @@ function Root$2({ actor, onSent, onFailed, children }) {
 		children
 	});
 }
-function Asset({ children }) {
+function Asset$1({ children }) {
 	return /* @__PURE__ */ jsx(Fragment, { children: children(useSendMoneyContext().asset) });
 }
 function Amount({ children }) {
@@ -1225,15 +1888,15 @@ function Amount({ children }) {
 function Recipient({ children }) {
 	return /* @__PURE__ */ jsx(Fragment, { children: children(useSendMoneyContext().recipient) });
 }
-function Actions({ children }) {
+function Actions$1({ children }) {
 	return /* @__PURE__ */ jsx(Fragment, { children: children(useSendMoneyContext().actions) });
 }
 /** The compound shape the app's own design system already uses (`StatusTabs`). */
-const CapxulSendMoney = Object.assign(Root$2, {
-	Asset,
+const CapxulSendMoney = Object.assign(Root$4, {
+	Asset: Asset$1,
 	Amount,
 	Recipient,
-	Actions
+	Actions: Actions$1
 });
 //#endregion
 //#region src/headless/access/org-member.tsx
@@ -1344,7 +2007,7 @@ function useOrgMemberContext() {
 	if (state === null) throw new Error("CapxulOrgMember parts must be used inside <CapxulOrgMember>");
 	return state;
 }
-function Root$1({ orgId, children }) {
+function Root$3({ orgId, children }) {
 	const state = useOrgMember(orgId);
 	return /* @__PURE__ */ jsx(OrgMemberContext.Provider, {
 		value: state,
@@ -1364,7 +2027,7 @@ function Standing({ children }) {
 	return /* @__PURE__ */ jsx(Fragment, { children: children(useOrgMemberContext().standing) });
 }
 /** The compound shape the app's own design system already uses (`StatusTabs`). */
-const CapxulOrgMember = Object.assign(Root$1, {
+const CapxulOrgMember = Object.assign(Root$3, {
 	Can,
 	Standing
 });
@@ -1511,7 +2174,7 @@ function usePart(phase) {
 	}, [placed, phase]);
 	return state.phase === phase ? state : null;
 }
-function Root({ scope, children }) {
+function Root$2({ scope, children }) {
 	const state = useDashboardAccess(scope);
 	const [placed] = useState(() => /* @__PURE__ */ new Set());
 	const value = useMemo(() => ({
@@ -1549,11 +2212,591 @@ function Granted({ children }) {
 	return usePart("granted") === null ? null : /* @__PURE__ */ jsx(Fragment, { children });
 }
 /** The compound shape the app's own design system already uses (`StatusTabs`). */
-const CapxulDashboardAccess = Object.assign(Root, {
+const CapxulDashboardAccess = Object.assign(Root$2, {
 	Checking,
 	Error: DashboardError,
 	Redirect,
 	Granted
 });
 //#endregion
-export { CapxulAuthenticationController, CapxulContacts, CapxulDashboardAccess, CapxulOnboardingController, CapxulOrgMember, CapxulProvider, CapxulSendMoney, acknowledgeOnboardingDestination, activeOnboardingRecovery, clearOnboardingJourney, currentOnboardingJourneyId, entered, invalidateOnboardingJourneyObservation, isClaimed, isRestoring, loadOnboardingJourney, onboardingJourneyPosition, saveOnboardingJourney, startOnboardingJourney, useCapxul, useCapxulAccountBalance, useCapxulAccountFund, useCapxulActivity, useCapxulActivityDetail, useCapxulAnnotateMovement, useCapxulAuth, useCapxulCancelPayment, useCapxulClaimPayment, useCapxulClientOrNull, useCapxulCreateCommitment, useCapxulCreateOrg, useCapxulDestination, useCapxulHoldings, useCapxulIdentity, useCapxulImageUpload, useCapxulInviteMember, useCapxulOrgMembers, useCapxulOrgRoles, useCapxulOrgTreasury, useCapxulOrganizationPay, useCapxulOrganizationPayBatch, useCapxulOrgs, useCapxulPay, useCapxulPayment, useCapxulPayments, useCapxulPermission, useCapxulPermissionAssign, useCapxulPermissionChange, useCapxulPermissionCreate, useCapxulPermissionReplace, useCapxulPermissionRevoke, useCapxulPermissions, useCapxulProfile, useCapxulRedirectPayment, useCapxulSend, useCapxulTransitions, useCapxulUsernameAvailability };
+//#region src/headless/payroll/money.ts
+/** `{ value: "12.34", decimals: 6 }` → `12340000n`. */
+function toMinorUnits(money) {
+	const [whole = "0", fraction = ""] = money.value.split(".");
+	return BigInt(`${whole}${fraction.padEnd(money.decimals, "0")}`);
+}
+const TYPED_AMOUNT = /^(-?)(\d+)(?:\.(\d+))?$/;
+/**
+* Σ of the employer's TYPED amounts on a saved group — a DISPLAY total.
+*
+* A group is a draft, so its amounts were never required to parse (backend
+* `payroll/groups.ts` validates the name and the recipients, never the money).
+* What cannot be read is skipped rather than poisoning the card's total, and
+* the widest fraction any member typed sets the scale so nothing rounds away.
+*/
+function sumTypedAmounts(amounts, currency) {
+	const parsed = amounts.map((amount) => TYPED_AMOUNT.exec(amount.trim().replaceAll(",", ""))).filter((match) => match !== null);
+	const decimals = parsed.reduce((widest, match) => Math.max(widest, (match[3] ?? "").length), 0);
+	return fromMinorUnits(parsed.reduce((sum, match) => {
+		const scaled = BigInt(`${match[2] ?? "0"}${(match[3] ?? "").padEnd(decimals, "0")}`);
+		return match[1] === "-" ? sum - scaled : sum + scaled;
+	}, 0n), {
+		currency,
+		decimals
+	});
+}
+/** The inverse, so a summed total can be formatted by the shipped `formatMoney`. */
+function fromMinorUnits(raw, asset) {
+	const negative = raw < 0n;
+	const digits = (negative ? -raw : raw).toString().padStart(asset.decimals + 1, "0");
+	const whole = digits.slice(0, digits.length - asset.decimals);
+	const fraction = asset.decimals === 0 ? "" : `.${digits.slice(digits.length - asset.decimals)}`;
+	return {
+		currency: asset.currency,
+		value: `${negative ? "-" : ""}${whole}${fraction}`,
+		decimals: asset.decimals
+	};
+}
+//#endregion
+//#region src/headless/payroll/reads.ts
+function toRecipientOption(entry) {
+	return {
+		id: entry.id,
+		name: entry.label,
+		email: entry.label.includes("@") ? entry.label : null
+	};
+}
+/**
+* The roster: active `employed` edges ∪ org members, deduped by party
+* (ruling Q1 = C).
+*
+* The organization address book computes exactly that union server-side —
+* members accumulate from `orgMembers`, employment is PROJECTED from open
+* `employed` edges, and both land in ONE map keyed by party
+* (`financialOps/addressBook.ts`). Contact edges live in the same book and are
+* not the roster, so the two relationships the roster is made of are the
+* filter.
+*/
+function useOrgRoster(orgId) {
+	const client = useCapxulClientOrNull();
+	const query = useQuery({
+		queryKey: capxulKeys.contactsList(orgId ?? "pending", false),
+		queryFn: async () => unwrapCapxulResult(await scopedClient(client, "org.addressBook.list", orgId).addressBook.list({ includeHidden: false })),
+		enabled: client !== null && orgId !== void 0
+	});
+	const entries = query.data;
+	return useMemo(() => {
+		const roster = (entries ?? []).filter((entry) => entry.relationship.includes("member") || entry.relationship.includes("employed"));
+		return {
+			options: roster.map(toRecipientOption),
+			refs: new Map(roster.map((entry) => [entry.id, entry.ref])),
+			isLoading: orgId !== void 0 && entries === void 0 && query.error === null,
+			error: query.error
+		};
+	}, [
+		entries,
+		orgId,
+		query.error
+	]);
+}
+function usePayrollGroups(orgId) {
+	const client = useCapxulClientOrNull();
+	return useQuery({
+		queryKey: capxulKeys.payrollGroups(orgId),
+		queryFn: async () => unwrapCapxulResult(await scopedClient(client, "org.payroll.groups.list", orgId).payroll.groups.list()),
+		enabled: client !== null && orgId !== void 0
+	});
+}
+function usePayrollRuns(orgId) {
+	const client = useCapxulClientOrNull();
+	return useQuery({
+		queryKey: capxulKeys.payrollRuns(orgId),
+		queryFn: async () => unwrapCapxulResult(await scopedClient(client, "org.payroll.runs", orgId).payroll.runs()),
+		enabled: client !== null && orgId !== void 0
+	});
+}
+function useOrgTreasury(orgId) {
+	const client = useCapxulClientOrNull();
+	return useQuery({
+		queryKey: capxulKeys.orgTreasury(orgId),
+		queryFn: async () => unwrapCapxulResult(await scopedClient(client, "org.treasury", orgId).treasury()),
+		enabled: client !== null && orgId !== void 0
+	});
+}
+/**
+* The caller's own standing, read for its Budgets alone (ruling Q2 grades
+* them). Keyed as `CapxulOrgMember` keys it, so a payroll screen inside a
+* `.Can` wrapper reads `org(id).me()` once.
+*/
+function useOrgMe(orgId) {
+	const client = useCapxulClientOrNull();
+	return useQuery({
+		queryKey: capxulKeys.orgMe(orgId),
+		queryFn: async () => unwrapCapxulResult(await scopedClient(client, "org.me", orgId).me()),
+		enabled: client !== null && orgId !== void 0
+	});
+}
+/**
+* The org-scoped bundle inside a query or mutation function. Every caller gates
+* on `orgId !== undefined`, so the second throw is only reachable from a
+* mutation fired while the provider is still bootstrapping.
+*/
+function scopedClient(client, method, orgId) {
+	const bootstrapped = requireBootstrappedClient(client, method);
+	if (orgId === void 0) throw Errors.invalidInput("orgId", `required for ${method}`);
+	return bootstrapped.org(orgId);
+}
+//#endregion
+//#region src/headless/payroll/use-payroll.ts
+/** Money reads the same way everywhere on this screen: amount then code. */
+const GRAMMAR$1 = { grammar: "code" };
+function toPayrollGroupRow(group) {
+	const currency = new Set(group.members.map((member) => member.currency)).size === 1 ? group.members[0]?.currency : void 0;
+	return {
+		id: group.id,
+		name: group.name,
+		tone: group.tone,
+		memberCount: group.members.length,
+		totalDisplay: currency === void 0 ? "" : formatMoney(sumTypedAmounts(group.members.map((member) => member.amount), currency), GRAMMAR$1),
+		members: group.members.map((member) => ({
+			recipientId: member.partyId,
+			amount: member.amount,
+			currency: member.currency
+		}))
+	};
+}
+/**
+* The validity `buildOrganizationPayrollGroupRecord` applied in the browser
+* (payroll groups hook `:57-82`) — a trimmed name, at least one deduped
+* recipient — checked here so an invalid group never costs a round trip. The
+* backend re-checks it; this is honest UX, not the authority.
+*
+* ADR-0023 R1: the refusal is a CODE, never a toast sentence.
+*/
+function invalidGroup(input) {
+	if (input.name.trim().length === 0) return Errors.invalidInput("name", "must not be empty");
+	const deduped = new Set(input.members.map((member) => member.partyId));
+	deduped.delete("");
+	return deduped.size === 0 ? Errors.invalidInput("members", "must not be empty") : null;
+}
+function usePayroll(orgId) {
+	const client = useCapxulClientOrNull();
+	const queryClient = useQueryClient();
+	const treasury = useOrgTreasury(orgId);
+	const runs = usePayrollRuns(orgId);
+	const groups = usePayrollGroups(orgId);
+	const write = useMutation({
+		mutationFn: async (command) => {
+			const payroll = scopedClient(client, `org.payroll.groups.${command.kind}`, orgId).payroll;
+			if (command.kind === "remove") {
+				unwrapCapxulResult(await payroll.groups.remove(command.id));
+				return null;
+			}
+			return unwrapCapxulResult(await payroll.groups.save(command.input));
+		},
+		onSettled: useCallback(() => queryClient.invalidateQueries({ queryKey: capxulKeys.payrollGroups(orgId) }), [orgId, queryClient])
+	});
+	const mutateAsync = write.mutateAsync;
+	const save = useCallback(async (input) => {
+		const refusal = invalidGroup(input);
+		if (refusal !== null) return {
+			ok: false,
+			error: refusal
+		};
+		try {
+			const saved = await mutateAsync({
+				kind: "save",
+				input
+			});
+			return saved === null ? {
+				ok: false,
+				error: Errors.unknown()
+			} : {
+				ok: true,
+				value: toPayrollGroupRow(saved)
+			};
+		} catch (cause) {
+			return {
+				ok: false,
+				error: asCapxulError(cause)
+			};
+		}
+	}, [mutateAsync]);
+	const remove = useCallback(async (id) => {
+		try {
+			await mutateAsync({
+				kind: "remove",
+				id
+			});
+			return {
+				ok: true,
+				value: void 0
+			};
+		} catch (cause) {
+			return {
+				ok: false,
+				error: asCapxulError(cause)
+			};
+		}
+	}, [mutateAsync]);
+	const rows = useMemo(() => (groups.data ?? []).map(toPayrollGroupRow), [groups.data]);
+	const started = orgId !== void 0;
+	return {
+		summary: {
+			walletBalanceDisplay: treasury.data === void 0 ? null : formatMoney(treasury.data.available, GRAMMAR$1),
+			paidThisMonthDisplay: runs.data === void 0 ? null : formatMoney(runs.data.settledThisMonth, GRAMMAR$1),
+			isLoading: started && (treasury.data === void 0 && treasury.error === null || runs.data === void 0 && runs.error === null),
+			error: treasury.error ?? runs.error
+		},
+		groups: {
+			groups: rows,
+			save,
+			remove,
+			isSaving: write.isPending,
+			isLoading: started && groups.data === void 0 && groups.error === null,
+			error: groups.error
+		}
+	};
+}
+/**
+* React Query rejects with whatever the query function threw. Every throw on
+* this path is a `CapxulError` the SDK produced; anything else is a defect and
+* normalizes once, exactly as the facade boundary does.
+*/
+function asCapxulError(cause) {
+	return isCapxulError$1(cause) ? cause : Errors.unknown(cause);
+}
+function isCapxulError$1(cause) {
+	return typeof cause === "object" && cause !== null && "code" in cause;
+}
+//#endregion
+//#region src/headless/payroll/payroll.tsx
+const PayrollContext = createContext(null);
+function usePayrollContext() {
+	const engine = useContext(PayrollContext);
+	if (engine === null) throw new Error("CapxulPayroll parts must be used inside <CapxulPayroll>");
+	return engine;
+}
+function Root$1({ orgId, children }) {
+	const engine = usePayroll(orgId);
+	return /* @__PURE__ */ jsx(PayrollContext.Provider, {
+		value: engine,
+		children
+	});
+}
+function Summary$1({ children }) {
+	return /* @__PURE__ */ jsx(Fragment, { children: children(usePayrollContext().summary) });
+}
+function Groups({ children }) {
+	return /* @__PURE__ */ jsx(Fragment, { children: children(usePayrollContext().groups) });
+}
+/**
+* The compound shape the app's own design system already uses (`StatusTabs`).
+* There is NO `.Runs` part (ruling Q6): no shipped region has the right shape
+* for a run list, and a part without a production caller may not ship.
+*/
+const CapxulPayroll = Object.assign(Root$1, {
+	Summary: Summary$1,
+	Groups
+});
+//#endregion
+//#region src/headless/payroll/use-payroll-run.ts
+const GRAMMAR = { grammar: "code" };
+/**
+* The one place the composer states a currency it has not read yet. The token
+* dropdown holds exactly one option — the treasury's — so before that read
+* lands there is no currency to name, and naming a wrong one would be a fake
+* green on the money itself.
+*/
+const CURRENCY_UNREAD = "";
+/**
+* WHICH run the composer is composing, by MEANING rather than by object shape.
+*
+* `recipientIds` order is meaning — it is the order `.Amounts` rows appear in.
+* The `amounts` order is not, so the key reads the seed `initialAmounts` will
+* actually build rather than the array it was handed: one collapse rule, in one
+* place, so the two can never disagree about a repeated recipient. A parent
+* that rebuilds an equivalent `prefill` therefore keeps its key, and the
+* employer's in-progress edits with it. An absent `prefill` and one that seeds
+* nothing open the same empty composer, so they share a key on purpose.
+*/
+function composerIdentity(orgId, prefill) {
+	const seeds = Object.entries(initialAmounts(prefill)).map(([recipientId, draft]) => `${recipientId}=${draft.value}`).sort();
+	return [
+		orgId ?? "",
+		...prefill?.recipientIds ?? [],
+		"|",
+		...seeds
+	].join("\0");
+}
+/** Seeded from `prefill` on first render; the employer owns it after that. */
+function initialAmounts(prefill) {
+	const seeded = {};
+	for (const entry of prefill?.amounts ?? []) seeded[entry.recipientId] = {
+		value: entry.amount,
+		prefilled: true
+	};
+	return seeded;
+}
+function usePayrollRun(input) {
+	const { orgId, prefill, onRun, onFailed } = input;
+	const client = useCapxulClientOrNull();
+	const queryClient = useQueryClient();
+	const signerStatus = useSignerStatus(client);
+	const roster = useOrgRoster(orgId);
+	const groups = usePayrollGroups(orgId);
+	const treasury = useOrgTreasury(orgId);
+	const me = useOrgMe(orgId);
+	const [selected, setSelected] = useState(() => prefill?.recipientIds ?? []);
+	const [amounts, setAmounts] = useState(() => initialAmounts(prefill));
+	const composerKey = composerIdentity(orgId, prefill);
+	const [seededKey, setSeededKey] = useState(composerKey);
+	if (seededKey !== composerKey) {
+		setSeededKey(composerKey);
+		setSelected(prefill?.recipientIds ?? []);
+		setAmounts(initialAmounts(prefill));
+	}
+	const toggle = useCallback((id) => setSelected((current) => current.includes(id) ? current.filter((held) => held !== id) : [...current, id]), []);
+	const remove = useCallback((id) => setSelected((current) => current.filter((held) => held !== id)), []);
+	const change = useCallback((id, text) => {
+		setAmounts((current) => ({
+			...current,
+			[id]: {
+				value: text,
+				prefilled: false
+			}
+		}));
+	}, []);
+	const account = treasury.data ?? null;
+	const assetOptions = useMemo(() => account === null ? [] : [{
+		id: account.id,
+		symbol: account.available.currency,
+		availableDisplay: formatMoney(account.available, GRAMMAR)
+	}], [account]);
+	const [selectedAssetId, setSelectedAssetId] = useState(null);
+	useEffect(() => {
+		if (!assetOptions.some((option) => option.id === selectedAssetId)) setSelectedAssetId(assetOptions[0]?.id ?? null);
+	}, [assetOptions, selectedAssetId]);
+	const selectedAsset = assetOptions.find((option) => option.id === selectedAssetId) ?? null;
+	const selectAsset = useCallback((id) => {
+		setSelectedAssetId((current) => assetOptions.some((option) => option.id === id) ? id : current);
+	}, [assetOptions]);
+	const assetMoney = selectedAsset !== null && account !== null ? account.available : null;
+	const named = useMemo(() => new Map(roster.options.map((option) => [option.id, option])), [roster.options]);
+	const refs = roster.refs;
+	const payableRefs = useMemo(() => {
+		const resolved = [];
+		for (const recipientId of selected) {
+			const ref = refs.get(recipientId);
+			if (ref === void 0) return null;
+			resolved.push(ref);
+		}
+		return resolved;
+	}, [refs, selected]);
+	const entries = useMemo(() => selected.map((recipientId) => {
+		const draft = amounts[recipientId];
+		const value = draft?.value ?? "";
+		const parsed = assetMoney === null || value.trim() === "" ? null : parseMoney(value, assetMoney);
+		return {
+			recipientId,
+			name: named.get(recipientId)?.name ?? recipientId,
+			value,
+			change: (text) => change(recipientId, text),
+			error: parsed !== null && isMoneyParseError(parsed) ? parsed.reason : null,
+			prefilled: draft?.prefilled ?? false,
+			currency: assetMoney?.currency ?? CURRENCY_UNREAD
+		};
+	}), [
+		amounts,
+		assetMoney,
+		change,
+		named,
+		selected
+	]);
+	const parsedAmounts = useMemo(() => {
+		if (assetMoney === null || selected.length === 0) return null;
+		const money = [];
+		for (const recipientId of selected) {
+			const parsed = parseMoney(amounts[recipientId]?.value ?? "", assetMoney);
+			if (isMoneyParseError(parsed)) return null;
+			money.push(parsed);
+		}
+		return money;
+	}, [
+		amounts,
+		assetMoney,
+		selected
+	]);
+	const total = useMemo(() => parsedAmounts === null || assetMoney === null ? null : fromMinorUnits(parsedAmounts.reduce((sum, money) => sum + toMinorUnits(money), 0n), assetMoney), [assetMoney, parsedAmounts]);
+	const availableRaw = assetMoney === null ? null : toMinorUnits(assetMoney);
+	const totalRaw = total === null ? null : toMinorUnits(total);
+	const funds = availableRaw === null || totalRaw === null ? "unknown" : totalRaw > availableRaw ? "insufficient" : "available";
+	const budgets = me.data?.budgets ?? [];
+	const blockedReason = firstFalseFact({
+		signerReady: signerStatus === "ready",
+		budgetCount: budgets.length,
+		hasAsset: selectedAsset !== null,
+		recipientCount: payableRefs === null ? 0 : selected.length,
+		amountsParse: total !== null,
+		funds
+	});
+	const authorize = useMutation({
+		mutationFn: async (command) => {
+			const runAt = Date.now();
+			return unwrapCapxulResult(await scopedClient(client, "org.payroll.authorizeRun", orgId).payroll.authorizeRun({
+				permissionId: command.permissionId,
+				period: {
+					start: runAt,
+					end: runAt
+				},
+				items: command.items
+			}));
+		},
+		onSettled: () => {
+			queryClient.invalidateQueries({ queryKey: capxulKeys.payrollRuns(orgId) });
+		}
+	});
+	const submitGate = useRef(false);
+	const totalDisplay = total === null ? null : formatMoney(total, GRAMMAR);
+	const authorizeMutate = authorize.mutate;
+	const submit = useCallback(() => {
+		const permissionId = budgets[0]?.id;
+		if (blockedReason !== null || submitGate.current) return;
+		if (permissionId === void 0 || totalDisplay === null || parsedAmounts === null) return;
+		if (payableRefs === null) return;
+		const recipientCount = selected.length;
+		const items = [];
+		for (const [index, recipientId] of selected.entries()) {
+			const to = payableRefs[index];
+			const parsed = parsedAmounts[index];
+			if (to === void 0 || parsed === void 0) return;
+			const raw = toMinorUnits(parsed).toString();
+			items.push({
+				to,
+				partyId: recipientId,
+				gross: raw,
+				net: raw,
+				adjustments: []
+			});
+		}
+		submitGate.current = true;
+		authorizeMutate({
+			permissionId,
+			items
+		}, {
+			onSuccess: (run) => onRun({
+				id: run.id,
+				totalDisplay,
+				recipientCount
+			}),
+			onError: onFailed,
+			onSettled: () => {
+				submitGate.current = false;
+			}
+		});
+	}, [
+		authorizeMutate,
+		blockedReason,
+		budgets,
+		onFailed,
+		onRun,
+		parsedAmounts,
+		payableRefs,
+		selected,
+		totalDisplay
+	]);
+	return {
+		recipients: {
+			options: roster.options,
+			groups: (groups.data ?? []).map((group) => ({
+				id: group.id,
+				label: group.name,
+				badgeLabel: String(group.members.length),
+				recipientIds: group.members.map((member) => member.partyId)
+			})),
+			selected,
+			toggle,
+			remove,
+			isLoading: roster.isLoading,
+			error: roster.error ?? groups.error
+		},
+		amounts: { entries },
+		asset: {
+			options: assetOptions,
+			selected: selectedAsset,
+			select: selectAsset,
+			error: treasury.error === null ? null : "read-failed"
+		},
+		summary: {
+			recipientCount: selected.length,
+			totalDisplay,
+			balanceAfterDisplay: totalRaw === null || availableRaw === null || assetMoney === null ? null : formatMoney(fromMinorUnits(availableRaw - totalRaw, assetMoney), GRAMMAR),
+			funds
+		},
+		actions: {
+			submit,
+			isSubmitting: authorize.isPending,
+			blocked: blockedReason !== null,
+			blockedReason
+		}
+	};
+}
+/**
+* The seven facts, in the ONE order the contract fixes. Exactly one code comes
+* out, and it is always the first thing that is false — so two problems never
+* race to name the button.
+*/
+function firstFalseFact(facts) {
+	if (!facts.signerReady) return "signer-not-ready";
+	if (facts.budgetCount === 0) return "no-source";
+	if (facts.budgetCount > 1) return "ambiguous-source";
+	if (!facts.hasAsset) return "no-asset";
+	if (facts.recipientCount === 0) return "no-recipients";
+	if (!facts.amountsParse) return "amount-invalid";
+	return facts.funds === "insufficient" ? "insufficient-funds" : null;
+}
+//#endregion
+//#region src/headless/payroll/payroll-run.tsx
+const PayrollRunContext = createContext(null);
+function usePayrollRunContext() {
+	const engine = useContext(PayrollRunContext);
+	if (engine === null) throw new Error("CapxulPayrollRun parts must be used inside <CapxulPayrollRun>");
+	return engine;
+}
+function Root({ orgId, prefill, onRun, onFailed, children }) {
+	const engine = usePayrollRun({
+		orgId,
+		prefill,
+		onRun,
+		onFailed
+	});
+	return /* @__PURE__ */ jsx(PayrollRunContext.Provider, {
+		value: engine,
+		children
+	});
+}
+function Recipients({ children }) {
+	return /* @__PURE__ */ jsx(Fragment, { children: children(usePayrollRunContext().recipients) });
+}
+function Amounts({ children }) {
+	return /* @__PURE__ */ jsx(Fragment, { children: children(usePayrollRunContext().amounts) });
+}
+function Asset({ children }) {
+	return /* @__PURE__ */ jsx(Fragment, { children: children(usePayrollRunContext().asset) });
+}
+function Summary({ children }) {
+	return /* @__PURE__ */ jsx(Fragment, { children: children(usePayrollRunContext().summary) });
+}
+function Actions({ children }) {
+	return /* @__PURE__ */ jsx(Fragment, { children: children(usePayrollRunContext().actions) });
+}
+/** The compound shape the app's own design system already uses (`StatusTabs`). */
+const CapxulPayrollRun = Object.assign(Root, {
+	Recipients,
+	Amounts,
+	Asset,
+	Summary,
+	Actions
+});
+//#endregion
+export { CapxulActivity, CapxulAuthenticationController, CapxulContacts, CapxulDashboardAccess, CapxulOnboardingController, CapxulOrgMember, CapxulPayroll, CapxulPayrollRun, CapxulProvider, CapxulSendMoney, acknowledgeOnboardingDestination, activeOnboardingRecovery, capxulKeys, clearOnboardingJourney, currentOnboardingJourneyId, entered, invalidateOnboardingJourneyObservation, isClaimed, isRestoring, loadOnboardingJourney, onboardingJourneyPosition, saveOnboardingJourney, startOnboardingJourney, useCapxul, useCapxulAccountBalance, useCapxulAccountFund, useCapxulActivity, useCapxulActivityDetail, useCapxulAnnotateMovement, useCapxulAuth, useCapxulCancelPayment, useCapxulClaimPayment, useCapxulClientOrNull, useCapxulCreateCommitment, useCapxulCreateOrg, useCapxulDestination, useCapxulHoldings, useCapxulIdentity, useCapxulImageUpload, useCapxulInviteMember, useCapxulOrgMembers, useCapxulOrgRoles, useCapxulOrgTreasury, useCapxulOrganizationPay, useCapxulOrganizationPayBatch, useCapxulOrgs, useCapxulPay, useCapxulPayment, useCapxulPayments, useCapxulPermission, useCapxulPermissionAssign, useCapxulPermissionChange, useCapxulPermissionCreate, useCapxulPermissionReplace, useCapxulPermissionRevoke, useCapxulPermissions, useCapxulProfile, useCapxulRedirectPayment, useCapxulSend, useCapxulTransitions, useCapxulUsernameAvailability };