@capxul/sdk-react 0.0.0-rc-2cdddbb91

package/dist/index.mjs

@@ -0,0 +1,3936 @@
+"use client";
+import { _ as orgKeySegment, a as entered, c as useCapxulIdentity, d as useCapxulTransitions, f as toInvocationControls, g as capxulKeys, h as actingAccount, i as CapxulProvider, l as useCapxulIdentityOrNull, m as accountKey, n as CapxulAuthenticationController, o as useCapxulAuth, p as toInvocationOptions, r as absurd, s as useCapxulDestination, t as CapxulOnboardingController, u as useCapxulSend, v as useCapxulClientOrNull, y as useCapxul } from "./onboarding-controller-DWuvVuC8.mjs";
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
+import { useInfiniteQuery, useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { CAPXUL_OPERATIONS, CapxulError, EVM_ADDRESS_RE, Errors, HANDLE_RE, PAYMENT_DIRECTIONS, PAYMENT_STATUSES, assetSymbolFor, fingerprintPaymentIntent, formatAssetAmount, formatMoney, isCapxulError, isClaimed, isClaimed as isClaimed$1, isMoneyParseError, isRestoring, isRestoring as isRestoring$1, parseAssetAmount, parseMoney, paymentPhase, requireAsset, resolveIdentityDestination, toAssetId, toCurrencyCode, toEvmAddress, toOrgId, toPartyId, toRaw, valueActivitySummary } from "@capxul/sdk";
+import { Fragment, jsx } from "react/jsx-runtime";
+//#region src/access/use-client-connection.ts
+function useClientConnection(input) {
+	const [view, setView] = useState(null);
+	const [pending, setPending] = useState(false);
+	const [error, setError] = useState(null);
+	const [resendReady, setResendReady] = useState(false);
+	const identityRef = useRef({
+		client: input.client,
+		requestId: input.requestId
+	});
+	identityRef.current = {
+		client: input.client,
+		requestId: input.requestId
+	};
+	const belongsHere = useCallback((client, requestId) => identityRef.current.client === client && identityRef.current.requestId === requestId, []);
+	const refresh = useCallback(async (signal) => {
+		const { client, requestId } = identityRef.current;
+		const result = await client.auth.clientRequests.read({ requestId }, signal === void 0 ? void 0 : { signal });
+		if (signal?.aborted || !belongsHere(client, requestId)) return;
+		if (result.ok) {
+			setView(result.value);
+			setError(null);
+			return;
+		}
+		setError(result.error);
+	}, [belongsHere]);
+	useEffect(() => {
+		setView(null);
+		setError(null);
+		setPending(false);
+		setResendReady(false);
+		const controller = new AbortController();
+		refresh(controller.signal);
+		return () => {
+			controller.abort();
+		};
+	}, [
+		input.client,
+		input.requestId,
+		refresh
+	]);
+	useEffect(() => {
+		if (view?.phase !== "otp_required") {
+			setResendReady(false);
+			return;
+		}
+		const remaining = view.resendAt - Date.now();
+		if (remaining <= 0) {
+			setResendReady(true);
+			return;
+		}
+		setResendReady(false);
+		const timer = setTimeout(() => setResendReady(true), remaining);
+		return () => clearTimeout(timer);
+	}, [view]);
+	const run = useCallback(async (work) => {
+		const { client, requestId } = identityRef.current;
+		setPending(true);
+		try {
+			const result = await work();
+			if (!belongsHere(client, requestId)) return;
+			if (!result.ok) {
+				setError(result.error);
+				return;
+			}
+			await refresh();
+		} finally {
+			if (belongsHere(client, requestId)) setPending(false);
+		}
+	}, [belongsHere, refresh]);
+	return useMemo(() => {
+		if (error !== null && (view === null || view.phase !== "refused")) return {
+			phase: "failure",
+			otp: null,
+			consent: null,
+			complete: null,
+			failure: {
+				code: error.code,
+				retry: () => refresh(),
+				cancel: async () => {
+					if (view === null) return;
+					const { client, requestId } = identityRef.current;
+					await run(() => client.auth.clientRequests.cancel({
+						requestId,
+						revision: view.revision
+					}));
+				}
+			}
+		};
+		if (view === null) return {
+			phase: "checking",
+			otp: null,
+			consent: null,
+			complete: null,
+			failure: null
+		};
+		if (view.phase === "otp_required") return {
+			phase: view.phase,
+			otp: {
+				email: view.email,
+				pending,
+				canResend: resendReady,
+				verifyCode: async (code) => {
+					const { client, requestId } = identityRef.current;
+					await run(() => client.auth.clientRequests.verifyOtp({
+						requestId,
+						code
+					}));
+				},
+				resend: async () => {
+					const { client, requestId } = identityRef.current;
+					await run(() => client.auth.clientRequests.sendOtp({ requestId }));
+				}
+			},
+			consent: null,
+			complete: null,
+			failure: null
+		};
+		if (view.phase === "review") return {
+			phase: view.phase,
+			otp: null,
+			consent: {
+				verifiedEmail: view.email,
+				clientLabel: view.clientLabel,
+				scopeCodes: view.scopes,
+				purpose: view.intent.mode,
+				setupState: view.setupState,
+				pending,
+				accept: async () => {
+					const { client, requestId } = identityRef.current;
+					await run(() => client.auth.clientRequests.accept({
+						requestId,
+						revision: view.revision
+					}));
+				},
+				cancel: async () => {
+					const { client, requestId } = identityRef.current;
+					await run(() => client.auth.clientRequests.cancel({
+						requestId,
+						revision: view.revision
+					}));
+				}
+			},
+			complete: null,
+			failure: null
+		};
+		if (view.phase === "connected") return {
+			phase: view.phase,
+			otp: null,
+			consent: null,
+			complete: { outcome: "connected" },
+			failure: null
+		};
+		if (view.phase === "refused") return {
+			phase: view.phase,
+			otp: null,
+			consent: null,
+			complete: null,
+			failure: {
+				code: view.code,
+				...view.field === void 0 ? {} : { field: view.field },
+				retry: () => refresh(),
+				cancel: async () => void 0
+			}
+		};
+		return {
+			phase: view.phase,
+			otp: null,
+			consent: null,
+			complete: null,
+			failure: null
+		};
+	}, [
+		error,
+		pending,
+		refresh,
+		resendReady,
+		run,
+		view
+	]);
+}
+//#endregion
+//#region src/access/client-connection.tsx
+const ConnectionContext = createContext(null);
+function useConnection() {
+	const engine = useContext(ConnectionContext);
+	if (engine === null) throw new Error("CapxulClientConnection parts must be used inside <CapxulClientConnection>");
+	return engine;
+}
+function Root$7({ client, requestId, children }) {
+	const engine = useClientConnection({
+		client,
+		requestId
+	});
+	return /* @__PURE__ */ jsx(ConnectionContext.Provider, {
+		value: engine,
+		children
+	});
+}
+function Checking$1({ children }) {
+	return useConnection().phase === "checking" ? /* @__PURE__ */ jsx(Fragment, { children }) : null;
+}
+function Otp({ children }) {
+	const otp = useConnection().otp;
+	return otp === null ? null : /* @__PURE__ */ jsx(Fragment, { children: children(otp) });
+}
+function Consent({ children }) {
+	const consent = useConnection().consent;
+	return consent === null ? null : /* @__PURE__ */ jsx(Fragment, { children: children(consent) });
+}
+function Complete({ children }) {
+	const complete = useConnection().complete;
+	return complete === null ? null : /* @__PURE__ */ jsx(Fragment, { children: children(complete) });
+}
+function Failure({ children }) {
+	const failure = useConnection().failure;
+	return failure === null ? null : /* @__PURE__ */ jsx(Fragment, { children: children(failure) });
+}
+const CapxulClientConnection = Object.assign(Root$7, {
+	Checking: Checking$1,
+	Otp,
+	Consent,
+	Complete,
+	Failure
+});
+//#endregion
+//#region src/platform/require-bootstrapped-client.ts
+/**
+* Narrow the bootstrap-nullable client to a ready client inside a query /
+* mutation function (sdk-provider-owned-bootstrap.md). Data hooks gate their
+* queries on `enabled: client !== null`, so this only ever throws for a mutation
+* triggered while `<CapxulProvider>` is still bootstrapping.
+*/
+function requireBootstrappedClient(client, method) {
+	if (client === null) throw Errors.wrongState({
+		method,
+		currentState: "bootstrapping",
+		validStates: ["ready"]
+	});
+	return client;
+}
+//#endregion
+//#region src/platform/unwrap-capxul-result.ts
+/**
+* Unwrap a `CapxulResult` for TanStack query/mutation functions and throw into
+* React Query's error path.
+*
+* Failure observation belongs to the core SDK method boundary. React does not
+* report the same logical failure a second time.
+*/
+function unwrapCapxulResult(result) {
+	if (result.ok) return result.value;
+	throw result.error;
+}
+//#endregion
+//#region src/organizations/use-org-me-reading.ts
+function useOrgMeReading(orgId) {
+	const client = useCapxulClientOrNull();
+	const identity = useCapxulIdentityOrNull();
+	const ready = client !== null && identity !== null && isClaimed$1(identity);
+	const mayStillOpen = client === null || identity === null || isRestoring$1(identity);
+	const query = useQuery({
+		queryKey: capxulKeys.orgMe(orgKeySegment(orgId), actingAccount(identity)),
+		queryFn: async () => {
+			return unwrapCapxulResult(await requireBootstrappedClient(client, CAPXUL_OPERATIONS.org.me).org(toOrgId(orgId)).me());
+		},
+		enabled: ready && orgId !== void 0
+	});
+	return useMemo(() => {
+		if (orgId === void 0) return { kind: "no-org" };
+		if (!ready) return { kind: mayStillOpen ? "loading" : "unavailable" };
+		if (query.error !== null) return { kind: "unavailable" };
+		if (query.data !== void 0) return {
+			kind: "ready",
+			me: query.data
+		};
+		return { kind: "loading" };
+	}, [
+		mayStillOpen,
+		orgId,
+		query.data,
+		query.error,
+		ready
+	]);
+}
+//#endregion
+//#region src/organizations/org-member.tsx
+const DENIED_NO_ORG = {
+	allowed: false,
+	isLoading: false,
+	reason: "org-unavailable"
+};
+const DENIED_LOADING = {
+	allowed: false,
+	isLoading: true,
+	reason: "loading"
+};
+const ALLOWED = {
+	allowed: true,
+	isLoading: false,
+	reason: null
+};
+const DENIED_NO_PERMISSION = {
+	allowed: false,
+	isLoading: false,
+	reason: "no-permission"
+};
+function canSlice(reading, held) {
+	switch (reading.kind) {
+		case "no-org":
+		case "unavailable": return DENIED_NO_ORG;
+		case "loading": return DENIED_LOADING;
+		case "ready": return held(reading.me) ? ALLOWED : DENIED_NO_PERMISSION;
+		default: return absurd(reading);
+	}
+}
+/**
+* The classification rule, derived line by line from the app's own expression
+* at `use-current-organization.ts:124-134`. Same order, same folds:
+*
+* | Test, in order                              | standing       |
+* | ------------------------------------------- | -------------- |
+* | the `me()` read has not settled             | `"loading"`    |
+* | the read errored, or no `orgId` was given   | `"unavailable"`|
+* | `role === null`                             | `"unavailable"`|
+* | `canManagePeople \|\| canSpend`             | `"active"`     |
+* | neither capability                          | `"restricted"` |
+*
+* `"unavailable"` folds TWO causes — a failed read and a member with no Role
+* label — exactly as today. And because the `role === null` test runs BEFORE
+* the capability test, `"active"` guarantees a non-null label, so no screen
+* needs a fallback word in that branch.
+*/
+function standingSlice(reading) {
+	if (reading.kind === "loading") return {
+		standing: "loading",
+		roleLabel: null
+	};
+	if (reading.kind !== "ready") return {
+		standing: "unavailable",
+		roleLabel: null
+	};
+	const { role, capabilities } = reading.me;
+	if (role === null) return {
+		standing: "unavailable",
+		roleLabel: null
+	};
+	return {
+		standing: capabilities.canManagePeople || capabilities.canSpend ? "active" : "restricted",
+		roleLabel: role.label
+	};
+}
+/** The engine — all the logic. NOT exported from the package barrel. */
+function useOrgMember(orgId) {
+	const reading = useOrgMeReading(orgId);
+	return useMemo(() => ({
+		can: {
+			spend: canSlice(reading, (me) => me.capabilities.canSpend),
+			managePeople: canSlice(reading, (me) => me.capabilities.canManagePeople)
+		},
+		standing: standingSlice(reading)
+	}), [reading]);
+}
+const OrgMemberContext = createContext(null);
+function useOrgMemberContext() {
+	const state = useContext(OrgMemberContext);
+	if (state === null) throw new Error("CapxulOrgMember parts must be used inside <CapxulOrgMember>");
+	return state;
+}
+function Root$6({ orgId, children }) {
+	const state = useOrgMember(orgId);
+	return /* @__PURE__ */ jsx(OrgMemberContext.Provider, {
+		value: state,
+		children
+	});
+}
+/**
+* One part serves all four denial idioms the app already uses: disabled with no
+* explanation, disabled plus a native `title`, a whole-surface swap, and
+* buttons that vanish. The part branches on nothing — the root computes both
+* slices and this picks the one the `do` prop names.
+*/
+function Can({ do: action, children }) {
+	return /* @__PURE__ */ jsx(Fragment, { children: children(useOrgMemberContext().can[action]) });
+}
+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$6, {
+	Can,
+	Standing
+});
+//#endregion
+//#region src/organizations/use-capxul-create-org.ts
+function useCapxulCreateOrg() {
+	const client = useCapxulClientOrNull();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (input) => {
+			return unwrapCapxulResult(await requireBootstrappedClient(client, CAPXUL_OPERATIONS.onboarding.completeOrganization).onboarding.completeOrganization(input));
+		},
+		onSuccess: async () => {
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.orgs });
+		}
+	});
+}
+//#endregion
+//#region src/organizations/use-capxul-org-members.ts
+function useCapxulOrgMembers(orgId, options) {
+	const client = useCapxulClientOrNull();
+	const enabled = options?.enabled ?? true;
+	return useQuery({
+		queryKey: capxulKeys.orgMembers(orgId),
+		queryFn: async () => {
+			if (orgId === void 0) throw Errors.invalidInput("orgId", "required for useCapxulOrgMembers");
+			return unwrapCapxulResult(await requireBootstrappedClient(client, CAPXUL_OPERATIONS.org.members).org(orgId).members());
+		},
+		enabled: client !== null && enabled && orgId !== void 0
+	});
+}
+//#endregion
+//#region src/organizations/use-capxul-org-roles.ts
+function useCapxulOrgRoles(orgId, options) {
+	const client = useCapxulClientOrNull();
+	const enabled = options?.enabled ?? true;
+	return useQuery({
+		queryKey: capxulKeys.orgRoles(orgId),
+		queryFn: async () => {
+			if (orgId === void 0) throw Errors.invalidInput("orgId", "required for useCapxulOrgRoles");
+			return unwrapCapxulResult(await requireBootstrappedClient(client, CAPXUL_OPERATIONS.org.roles).org(orgId).roles());
+		},
+		enabled: client !== null && enabled && orgId !== void 0
+	});
+}
+//#endregion
+//#region src/organizations/use-capxul-org-treasury.ts
+function useCapxulOrgTreasury(orgId, options) {
+	const client = useCapxulClientOrNull();
+	const identity = useCapxulIdentityOrNull();
+	const enabled = options?.enabled ?? true;
+	return useQuery({
+		queryKey: accountKey(capxulKeys.orgTreasury(orgId), identity),
+		queryFn: async () => {
+			if (orgId === void 0) throw Errors.invalidInput("orgId", "required for useCapxulOrgTreasury");
+			return unwrapCapxulResult(await requireBootstrappedClient(client, CAPXUL_OPERATIONS.org.treasury).org(orgId).treasury());
+		},
+		enabled: client !== null && enabled && orgId !== void 0
+	});
+}
+//#endregion
+//#region src/organizations/use-capxul-orgs.ts
+function useCapxulOrgs(options) {
+	const client = useCapxulClientOrNull();
+	const identity = useCapxulIdentityOrNull();
+	return useQuery({
+		queryKey: accountKey(capxulKeys.orgs, identity),
+		queryFn: async () => {
+			return unwrapCapxulResult(await requireBootstrappedClient(client, "orgs").orgs());
+		},
+		enabled: client !== null && (options?.enabled ?? true)
+	});
+}
+//#endregion
+//#region src/access/use-dashboard-access.ts
+function isOrgLaneSettled(identity) {
+	if (identity.phase !== "authenticated" || identity.account.at !== "claimed") return true;
+	const org = identity.account.org;
+	if (org === null) return true;
+	return org.observation === "connected" && org.setup !== null;
+}
+function decidePhase(input) {
+	if (input.error !== null) return "error";
+	if (!input.settled) return "checking";
+	if (input.granted) return "granted";
+	if (input.orgLaneSettled && input.destination !== null) return "redirect";
+	return "checking";
+}
+function useDashboardAccess(scope) {
+	const client = useCapxulClientOrNull();
+	const queryClient = useQueryClient();
+	const identity = useCapxulIdentityOrNull();
+	const destination = useMemo(() => destinationOrNull(identity), [identity]);
+	const orgId = scope.kind === "organization" ? scope.orgId : void 0;
+	const claimed = isClaimedOrFalse(identity);
+	const scopeKey = `${orgId ?? ""}:${identity?.phase === "authenticated" ? identity.session.authUserId : ""}:${actingAccount(identity) ?? ""}`;
+	const [observation, setObservation] = useState({
+		scopeKey,
+		status: "loading"
+	});
+	const [subscriptionRetry, setSubscriptionRetry] = useState(0);
+	const sessionError = useMemo(() => identity?.phase === "faulted" ? identityError(identity) : null, [identity]);
+	const wantsMemberships = orgId !== void 0 && claimed;
+	const memberships = useCapxulOrgs({ enabled: wantsMemberships });
+	const membershipError = wantsMemberships ? memberships.error : null;
+	const membershipsSettled = !wantsMemberships || memberships.data !== void 0 || membershipError !== null;
+	const hasMembership = orgId !== void 0 && (memberships.data?.items ?? []).some((organization) => String(organization.id) === orgId);
+	const wantsLifecycle = wantsMemberships && membershipsSettled && hasMembership;
+	const orgKey = orgKeySegment(orgId);
+	const setupKey = accountKey(capxulKeys.orgLifecycle(orgKey), identity);
+	const lifecycle = useQuery({
+		queryKey: setupKey,
+		queryFn: async () => {
+			return unwrapCapxulResult(await requireBootstrappedClient(client, CAPXUL_OPERATIONS.organization.setup).org(toOrgId(orgId)).setup.get());
+		},
+		enabled: wantsLifecycle && client !== null
+	});
+	const meKey = capxulKeys.orgMe(orgKey, actingAccount(identity));
+	useEffect(() => {
+		if (!wantsLifecycle || client === null || orgKey === void 0) return;
+		const controller = new AbortController();
+		let closed = false;
+		let stop = null;
+		setObservation({
+			scopeKey,
+			status: "loading"
+		});
+		client.org(orgKey).setup.subscribe((snapshot) => {
+			if (closed) return;
+			if (snapshot.status === "value") {
+				const value = queryClient.setQueryData(setupKey, snapshot.value) ?? snapshot.value;
+				setObservation({
+					scopeKey,
+					status: "value",
+					value
+				});
+			} else if (snapshot.status === "error") setObservation({
+				scopeKey,
+				status: "error",
+				error: snapshot.error
+			});
+		}, { signal: controller.signal }).then((result) => {
+			if (!result.ok) {
+				if (!closed) setObservation({
+					scopeKey,
+					status: "error",
+					error: result.error
+				});
+				return;
+			}
+			stop = result.value;
+			if (closed) stop();
+		}).catch((cause) => {
+			if (!closed) setObservation({
+				scopeKey,
+				status: "error",
+				error: isCapxulError(cause) ? cause : new CapxulError("UNKNOWN", "Organization setup subscription failed", { cause })
+			});
+		});
+		return () => {
+			closed = true;
+			controller.abort();
+			stop?.();
+		};
+	}, [
+		client,
+		orgKey,
+		wantsLifecycle,
+		queryClient,
+		scopeKey,
+		subscriptionRetry
+	]);
+	const currentSetup = observation.scopeKey === scopeKey && observation.status === "value" ? observation.value : void 0;
+	const wantsAuthority = wantsLifecycle && currentSetup?.status === "ready";
+	const authority = useQuery({
+		queryKey: meKey,
+		queryFn: async () => {
+			return unwrapCapxulResult(await requireBootstrappedClient(client, CAPXUL_OPERATIONS.org.me).org(toOrgId(orgId)).me());
+		},
+		enabled: wantsAuthority && client !== null
+	});
+	const [checkedScope, setCheckedScope] = useState(null);
+	useEffect(() => {
+		if (!wantsAuthority) {
+			setCheckedScope(null);
+			return;
+		}
+		let active = true;
+		authority.refetch().then((result) => {
+			if (active && result.isSuccess) setCheckedScope(scopeKey);
+		});
+		return () => {
+			active = false;
+		};
+	}, [
+		scopeKey,
+		currentSetup,
+		wantsAuthority,
+		authority.refetch
+	]);
+	const authorityCurrent = checkedScope === scopeKey && authority.data !== void 0;
+	const observationError = observation.scopeKey === scopeKey && observation.status === "error" ? observation.error : void 0;
+	const lifecycleError = wantsLifecycle ? observationError ?? lifecycle.error : null;
+	const authorityError = wantsAuthority ? authority.error : null;
+	const lifecycleSettled = !wantsLifecycle || lifecycleError !== null || authorityError !== null || isLifecycleSettled(currentSetup) && (!wantsAuthority || authorityCurrent);
+	const retry = useCallback(() => {
+		if (sessionError !== null && client !== null) client.auth.getSession();
+		if (membershipError !== null) memberships.refetch();
+		if (observationError !== void 0) setSubscriptionRetry((attempt) => attempt + 1);
+		if (lifecycleError !== null) lifecycle.refetch();
+		if (authorityError !== null) authority.refetch();
+	}, [
+		client,
+		sessionError,
+		membershipError,
+		observationError,
+		lifecycleError,
+		memberships.refetch,
+		lifecycle.refetch,
+		authorityError,
+		authority.refetch
+	]);
+	const error = sessionError ?? membershipError ?? lifecycleError ?? authorityError;
+	const probe = probeOf(sessionError, membershipError, lifecycleError, authorityError);
+	const phase = decidePhase({
+		error,
+		settled: client !== null && identity !== null && !isRestoring$1(identity) && membershipsSettled && lifecycleSettled,
+		granted: scope.kind === "personal" ? claimed : claimed && orgId !== void 0 && hasMembership && isExactOrgReady(currentSetup, orgId) && authorityCurrent,
+		orgLaneSettled: identity !== null && isOrgLaneSettled(identity),
+		destination
+	});
+	return useMemo(() => ({
+		phase,
+		error,
+		probe,
+		destination,
+		retry
+	}), [
+		phase,
+		error,
+		probe,
+		destination,
+		retry
+	]);
+}
+//#endregion
+//#region src/access/dashboard-access.tsx
+const PART_NAME = {
+	checking: "Checking",
+	error: "Error",
+	redirect: "Redirect",
+	granted: "Granted"
+};
+/**
+* Mirrors `publicIdentityFailure`, which is internal to `@capxul/sdk`
+* (`src/surface/_shared/effect-actor-bridge.ts`). The identity machine carries
+* its own failure representation; `.Error` hands a `CapxulError`, so the
+* projection happens once, here.
+*/
+function identityError(state) {
+	const { failure } = state;
+	if (failure.error !== void 0) return failure.error;
+	return new CapxulError(failure.code === "WORK_DIED" ? "UNKNOWN" : failure.code, failure.message, {
+		layer: "identity",
+		...failure.mode === void 0 ? {} : { mode: failure.mode }
+	});
+}
+/** Exactly the Organization asked for, and ready to be used. */
+function isExactOrgReady(lifecycle, orgId) {
+	return lifecycle?.status === "ready" && String(lifecycle.orgId) === orgId;
+}
+function isLifecycleSettled(lifecycle) {
+	return lifecycle !== void 0;
+}
+function destinationOrNull(identity) {
+	return identity === null ? null : resolveIdentityDestination(identity);
+}
+function isClaimedOrFalse(identity) {
+	return identity !== null && isClaimed$1(identity);
+}
+/**
+* Which probe produced the surfaced error — the SAME precedence `error` itself
+* is chosen by, written once so the code and its source can never disagree.
+*/
+function probeOf(session, membership, lifecycle, authority) {
+	if (session !== null) return "session";
+	if (membership !== null) return "membership";
+	if (lifecycle !== null) return "lifecycle";
+	if (authority !== null) return "authority";
+	return null;
+}
+const DashboardAccessContext = createContext(null);
+function useDashboardAccessContext() {
+	const value = useContext(DashboardAccessContext);
+	if (value === null) throw new Error("CapxulDashboardAccess parts must be used inside <CapxulDashboardAccess>");
+	return value;
+}
+/** A part's own turn, and its registration for the missing-part warning. */
+function usePart(phase) {
+	const { state, placed } = useDashboardAccessContext();
+	useEffect(() => {
+		placed.add(phase);
+		return () => {
+			placed.delete(phase);
+		};
+	}, [placed, phase]);
+	return state.phase === phase ? state : null;
+}
+function Root$5({ scope, children }) {
+	const state = useDashboardAccess(scope);
+	const [placed] = useState(() => /* @__PURE__ */ new Set());
+	const value = useMemo(() => ({
+		state,
+		placed
+	}), [state, placed]);
+	useEffect(() => {
+		if (typeof process !== "undefined" && process.env.NODE_ENV === "production") return;
+		if (placed.has(state.phase)) return;
+		console.warn(`<CapxulDashboardAccess> reached "${state.phase}" but no <CapxulDashboardAccess.${PART_NAME[state.phase]}> is placed, so nothing renders.`);
+	}, [placed, state.phase]);
+	return /* @__PURE__ */ jsx(DashboardAccessContext.Provider, {
+		value,
+		children
+	});
+}
+/** Hands nothing — today's app renders `null` here, exactly as it does now. */
+function Checking({ children }) {
+	return usePart("checking") === null ? null : /* @__PURE__ */ jsx(Fragment, { children });
+}
+function DashboardError({ children }) {
+	const state = usePart("error");
+	if (state === null || state.error === null || state.probe === null) return null;
+	return /* @__PURE__ */ jsx(Fragment, { children: children({
+		error: state.error,
+		probe: state.probe,
+		retry: state.retry
+	}) });
+}
+/**
+* Hands the destination and draws nothing. Reaching this part is a REQUEST to
+* navigate, never an arrival: the app may cancel or supersede it, so nothing
+* here — and nothing a consumer hangs off it — may claim a completed redirect
+* (#1963 R05-1). The destination page's own normalized pageview proves arrival.
+*/
+function Redirect({ children }) {
+	const state = usePart("redirect");
+	if (state === null || state.destination === null) return null;
+	return /* @__PURE__ */ jsx(Fragment, { children: children({ destination: state.destination }) });
+}
+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$5, {
+	Checking,
+	Error: DashboardError,
+	Redirect,
+	Granted
+});
+//#endregion
+//#region ../protocol/src/primitives/record.ts
+/** A non-null object that is not an array: a value whose fields can be read by name. */
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/profiles/journey-validation.ts
+/** A stored journey is current, well-formed field by field, and consistent across fields. */
+function isValidJourney(value) {
+	return isRecord(value) && value.version === 1 && hasJourneyFields(value) && hasConsistentJourney(value);
+}
+function hasJourneyFields(value) {
+	if (!hasOnlyKeys(value, [
+		"version",
+		"ownerId",
+		"journeyId",
+		"intent",
+		"entryPoint",
+		"origin",
+		"step",
+		"profile",
+		"organization",
+		"stableHandle",
+		"organizationId",
+		"submission"
+	])) return false;
+	if (!isBoundedId(value.ownerId)) return false;
+	if (!isBoundedId(value.journeyId) || !value.journeyId.startsWith("journey_")) return false;
+	if (value.intent !== "personal" && value.intent !== "organization") return false;
+	if (value.entryPoint !== "signup" && value.entryPoint !== "dashboard") return false;
+	if (value.step !== "profile" && value.step !== "organization" && value.step !== "provisioning") return false;
+	if (value.origin !== void 0 && !isOrigin(value.origin)) return false;
+	if (value.profile !== void 0 && !isProfileDraft(value.profile)) return false;
+	if (value.organization !== void 0 && !isOrganizationDraft(value.organization)) return false;
+	if (value.submission !== void 0 && !isCreateOrganizationSubmission(value.submission)) return false;
+	if (value.stableHandle !== void 0 && !isDraftText(value.stableHandle)) return false;
+	if (value.organizationId !== void 0 && !isBoundedId(value.organizationId)) return false;
+	return true;
+}
+/** The handle, intent, step and Organization agree with one another. */
+function hasConsistentJourney(value) {
+	if (isRecord(value.organization) && value.stableHandle !== value.organization.handle) return false;
+	if (value.organization === void 0 && value.stableHandle !== void 0) return false;
+	if (value.intent === "personal" && (value.step === "organization" || value.organization !== void 0 || value.stableHandle !== void 0)) return false;
+	if (value.step === "organization" && value.intent !== "organization") return false;
+	if (value.organizationId !== void 0 && value.intent !== "organization") return false;
+	if (value.organizationId !== void 0 && value.step !== "provisioning") return false;
+	return true;
+}
+function isOrigin(value) {
+	if (!isRecord(value)) return false;
+	if (value.kind === "personal") return hasOnlyKeys(value, ["kind"]);
+	if (value.kind === "organization") return hasOnlyKeys(value, ["kind", "organizationId"]) && isBoundedId(value.organizationId);
+	return value.kind === "verification" && hasOnlyKeys(value, ["kind", "organizationId"]) && (value.organizationId === void 0 || isBoundedId(value.organizationId));
+}
+function isProfileDraft(value) {
+	if (!isRecord(value) || !hasOnlyKeys(value, [
+		"displayName",
+		"country",
+		"withdrawalAddress",
+		"handle",
+		"payoutAddresses",
+		"imageStorageId"
+	]) || !isDraftText(value.displayName) || !isDraftText(value.country) || !isDraftText(value.withdrawalAddress)) return false;
+	if (value.handle !== void 0 && !isDraftText(value.handle)) return false;
+	if (value.payoutAddresses !== void 0 && !isPayoutDraftList(value.payoutAddresses)) return false;
+	if (value.imageStorageId !== void 0 && !isBoundedId(value.imageStorageId)) return false;
+	return true;
+}
+/**
+* The submitted organization (#1955). ONE validator now — the app's duplicate
+* of it is deleted, so a submit cannot be written by two writers with
+* disagreeing rules and then rejected here.
+*/
+function isCreateOrganizationSubmission(value) {
+	if (!isRecord(value) || !hasOnlyKeys(value, ["profileDetails", "organization"])) return false;
+	const { profileDetails, organization } = value;
+	if (!isRecord(profileDetails) || !hasOnlyKeys(profileDetails, [
+		"displayName",
+		"country",
+		"handle",
+		"imageStorageId",
+		"payoutAddresses"
+	]) || !isDraftText(profileDetails.displayName) || !isDraftText(profileDetails.country) || !isDraftText(profileDetails.handle)) return false;
+	if (profileDetails.imageStorageId !== void 0 && !isBoundedId(profileDetails.imageStorageId)) return false;
+	if (profileDetails.payoutAddresses !== void 0 && !isPayoutDraftList(profileDetails.payoutAddresses)) return false;
+	return isOrganizationDraft(organization);
+}
+function isPayoutDraftList(value) {
+	return Array.isArray(value) && value.length <= 10 && value.every((entry) => isRecord(entry) && hasOnlyKeys(entry, ["chain", "address"]) && (entry.chain === "evm" || entry.chain === "solana" || entry.chain === "starknet") && isDraftText(entry.address));
+}
+function isOrganizationDraft(value) {
+	if (!isRecord(value) || !hasOnlyKeys(value, [
+		"name",
+		"handle",
+		"country",
+		"bio",
+		"size",
+		"logoStorageId"
+	]) || !isDraftText(value.name) || !isDraftText(value.handle) || !isDraftText(value.country)) return false;
+	if (value.bio !== void 0 && !isDraftText(value.bio)) return false;
+	if (value.size !== void 0 && !isDraftText(value.size)) return false;
+	if (value.logoStorageId !== void 0 && !isBoundedId(value.logoStorageId)) return false;
+	return true;
+}
+function isDraftText(value) {
+	return typeof value === "string" && value.length <= 200;
+}
+function isBoundedId(value) {
+	return typeof value === "string" && value.length > 0 && value.length <= 160;
+}
+function hasOnlyKeys(value, allowed) {
+	return Object.keys(value).every((key) => allowed.includes(key));
+}
+//#endregion
+//#region src/profiles/journey-state.ts
+const JOURNEY_KEY = "capxul.onboarding.journey.v1";
+const VALIDATED_OWNER_KEY = "capxul.onboarding.validated-owner.v1";
+const MAX_STORED_JOURNEY_LENGTH = 8192;
+/**
+* The owner whose stored journey may currently be attributed to observations.
+* Persisted in sessionStorage rather than module memory so `currentOnboarding-
+* JourneyId` is a pure function of durable state — attribution is the same
+* regardless of the order of renders, reloads, or telemetry emits. Established
+* only when an authenticated owner is (journey start, or an owner-matched load)
+* and cleared at every auth boundary or on discard.
+*/
+function markOnboardingOwnerValidated(ownerId) {
+	try {
+		sessionStorage.setItem(VALIDATED_OWNER_KEY, ownerId);
+	} catch {}
+}
+function clearValidatedOnboardingOwner() {
+	try {
+		sessionStorage.removeItem(VALIDATED_OWNER_KEY);
+	} catch {}
+}
+function validatedOnboardingOwner() {
+	try {
+		return sessionStorage.getItem(VALIDATED_OWNER_KEY);
+	} catch {
+		return null;
+	}
+}
+function startOnboardingJourney(input) {
+	const journey = {
+		version: 1,
+		ownerId: input.ownerId,
+		journeyId: `journey_${createRandomId()}`,
+		intent: input.intent,
+		entryPoint: input.entryPoint,
+		step: input.step ?? "profile",
+		...input.origin === void 0 ? {} : { origin: input.origin }
+	};
+	markOnboardingOwnerValidated(journey.ownerId);
+	saveOnboardingJourney(journey);
+	return journey;
+}
+function loadOnboardingJourney(expectedOwnerId) {
+	try {
+		const raw = sessionStorage.getItem(JOURNEY_KEY);
+		if (raw === null) return null;
+		if (raw.length > MAX_STORED_JOURNEY_LENGTH) return discardInvalidJourney();
+		const value = migrateStoredJourney(JSON.parse(raw));
+		if (!isValidJourney(value)) return discardInvalidJourney();
+		if (expectedOwnerId !== void 0 && value.ownerId !== expectedOwnerId) return discardInvalidJourney();
+		if (expectedOwnerId !== void 0) markOnboardingOwnerValidated(expectedOwnerId);
+		return value;
+	} catch {
+		return discardInvalidJourney();
+	}
+}
+function migrateStoredJourney(value) {
+	if (!isRecord(value) || !isRecord(value.origin) || value.origin.kind !== "proof") return value;
+	const migrated = {
+		...value,
+		origin: {
+			...value.origin,
+			kind: "verification"
+		}
+	};
+	try {
+		sessionStorage.setItem(JOURNEY_KEY, JSON.stringify(migrated));
+	} catch {}
+	return migrated;
+}
+function saveOnboardingJourney(journey) {
+	if (!isValidJourney(journey)) {
+		discardInvalidJourney();
+		return;
+	}
+	try {
+		sessionStorage.setItem(JOURNEY_KEY, JSON.stringify(journey));
+	} catch {}
+}
+function currentOnboardingJourneyId() {
+	const journey = loadOnboardingJourney();
+	const owner = validatedOnboardingOwner();
+	return journey !== null && owner !== null && journey.ownerId === owner ? journey.journeyId : void 0;
+}
+/** Stop observation attribution while no authenticated owner is established. */
+function invalidateOnboardingJourneyObservation() {
+	clearValidatedOnboardingOwner();
+}
+/** Where the journey stands — the pure position apps map to their routes. */
+function onboardingJourneyPosition(journey) {
+	const verification = journey.origin?.kind === "verification";
+	if (journey.organizationId !== void 0) return {
+		intent: journey.intent,
+		step: "provisioning",
+		organizationId: journey.organizationId,
+		verification
+	};
+	return {
+		intent: journey.intent,
+		step: journey.step,
+		verification
+	};
+}
+/**
+* The interruption-recovery decision (behavior map §4): a journey that does
+* not match the ready destination the app just rendered must resume; a
+* matching one needs no recovery. Returns the journey to resume, or null.
+*/
+function activeOnboardingRecovery(ownerId, renderedReadyDestination) {
+	const journey = loadOnboardingJourney(ownerId);
+	if (journey === null) return null;
+	return (renderedReadyDestination?.kind === "personal" ? journey.intent === "personal" && journey.step === "provisioning" && journey.organizationId === void 0 : renderedReadyDestination?.kind === "organization" && journey.intent === "organization" && journey.step === "provisioning" && journey.organizationId === renderedReadyDestination.organizationId) ? null : journey;
+}
+function acknowledgeOnboardingDestination(destination, ownerId) {
+	const journey = loadOnboardingJourney(ownerId);
+	if (journey === null) return false;
+	if (!(destination.kind === "personal" ? journey.intent === "personal" && journey.step === "provisioning" : journey.intent === "organization" && journey.step === "provisioning" && journey.organizationId === destination.organizationId)) return false;
+	clearOnboardingJourney();
+	return true;
+}
+function clearOnboardingJourney() {
+	clearValidatedOnboardingOwner();
+	try {
+		sessionStorage.removeItem(JOURNEY_KEY);
+	} catch {}
+}
+function discardInvalidJourney() {
+	clearValidatedOnboardingOwner();
+	try {
+		sessionStorage.removeItem(JOURNEY_KEY);
+	} catch {}
+	return null;
+}
+function createRandomId() {
+	if (typeof globalThis.crypto?.randomUUID === "function") return globalThis.crypto.randomUUID();
+	return Math.random().toString(36).slice(2);
+}
+//#endregion
+//#region src/platform/use-debounced-value.ts
+/** The value as of `delayMs` after its last change (initial value immediate). */
+function useDebouncedValue(value, delayMs) {
+	const [debounced, setDebounced] = useState(value);
+	useEffect(() => {
+		const timer = setTimeout(() => setDebounced(value), delayMs);
+		return () => clearTimeout(timer);
+	}, [value, delayMs]);
+	return debounced;
+}
+//#endregion
+//#region src/profiles/use-capxul-handle-availability.ts
+/**
+* #1062: debounced availability probe for the handle the user is typing.
+* Disabled until the candidate reaches the 3-character floor; a malformed or
+* reserved candidate surfaces as the query's error (INVALID_INPUT with the
+* boundary's message), not as `available: false` — only a handle someone
+* else owns is "taken".
+*/
+function useCapxulHandleAvailability(handle, options) {
+	const client = useCapxulClientOrNull();
+	const candidate = useDebouncedValue(handle.trim(), options?.debounceMs ?? 300);
+	return useQuery({
+		queryKey: capxulKeys.handleAvailability(candidate),
+		queryFn: async () => {
+			return unwrapCapxulResult(await requireBootstrappedClient(client, CAPXUL_OPERATIONS.identity.handleAvailable).identity.handleAvailable(candidate));
+		},
+		enabled: client !== null && candidate.length >= 3 && (options?.enabled ?? true)
+	});
+}
+//#endregion
+//#region src/profiles/use-capxul-profile.ts
+function useCapxulProfile() {
+	const client = useCapxulClientOrNull();
+	const identity = useCapxulIdentityOrNull();
+	return useQuery({
+		queryKey: [...capxulKeys.profile, identity?.phase === "authenticated" ? identity.session.authUserId : null],
+		queryFn: async () => unwrapCapxulResult(await requireBootstrappedClient(client, CAPXUL_OPERATIONS.identity.loadCurrent).identity.loadCurrent()),
+		enabled: client !== null && identity?.phase === "authenticated"
+	});
+}
+//#endregion
+//#region src/accounts/use-capxul-account-balance.ts
+function useCapxulAccountBalance(options) {
+	const client = useCapxulClientOrNull();
+	const identity = useCapxulIdentityOrNull();
+	return useQuery({
+		queryKey: accountKey(capxulKeys.accountBalance, identity),
+		queryFn: async () => {
+			return unwrapCapxulResult(await requireBootstrappedClient(client, CAPXUL_OPERATIONS.accounts.read).accounts.read());
+		},
+		enabled: client !== null && (options?.enabled ?? true)
+	});
+}
+//#endregion
+//#region src/accounts/use-capxul-account-fund.ts
+function useCapxulAccountFund() {
+	const client = useCapxulClientOrNull();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (amount) => {
+			return unwrapCapxulResult(await requireBootstrappedClient(client, CAPXUL_OPERATIONS._internal.accounts.fund)._internal.accounts.fund(amount));
+		},
+		onSuccess: async () => {
+			await queryClient.invalidateQueries({ queryKey: capxulKeys.accountBalance });
+		}
+	});
+}
+//#endregion
+//#region src/accounts/use-capxul-holdings.ts
+function useCapxulHoldings(params) {
+	const client = useCapxulClientOrNull();
+	const identity = useCapxulIdentityOrNull();
+	const actor = params?.actor;
+	return useQuery({
+		queryKey: accountKey(capxulKeys.holdings(actor), identity),
+		queryFn: async () => {
+			return unwrapCapxulResult(await requireBootstrappedClient(client, CAPXUL_OPERATIONS.holdings.current).holdings.current(actor === void 0 ? void 0 : { actor }));
+		},
+		enabled: client !== null && identity !== null && isClaimed$1(identity)
+	});
+}
+//#endregion
+//#region src/payments/asset-selections.ts
+/**
+* One Send `.Asset` option per position the Account holds, taken from
+* `account.balances` — never from `account.available`, which is the Account's
+* fiat VALUATION of those positions (ADR-0028 R5/R6). Labelling the valuation
+* was the false identity this cut removes, and it collapsed USDC+USDT into one
+* "USD" row.
+*
+* The option is keyed on the ASSET id, never the symbol and never the account:
+* several positions share one account id, and a symbol is display only
+* (ADR-0028 R3). Every row is listed, so a real multi-position Account still
+* offers its holdings.
+*/
+function assetSelectionsFromAccount(account) {
+	if (account === null) return [];
+	return account.balances.map((position) => {
+		return {
+			option: {
+				id: position.asset,
+				symbol: position.symbol,
+				availableDisplay: formatAssetAmount({
+					asset: position.asset,
+					value: position.available
+				})
+			},
+			money: {
+				asset: position.asset,
+				value: position.available
+			}
+		};
+	});
+}
+//#endregion
+//#region src/payments/invalidate-money-state.ts
+/**
+* Invalidate what a settled money mutation changed, for the actor it ran as.
+*
+* #1145 (DEMOLITION §D5): the insights, address-book and org-`account`
+* invalidations this used to fan out to named queries that no hook creates any
+* more — the actor-scope family and `useCapxulOrganizationAccount` are deleted.
+* Invalidating a key nothing reads is a no-op that reads as coverage.
+*/
+async function invalidateMoneyState(queryClient, input) {
+	const invalidations = [queryClient.invalidateQueries({ queryKey: capxulKeys.payments })];
+	if (input.payment !== void 0) invalidations.push(queryClient.invalidateQueries({ queryKey: capxulKeys.payment(input.payment.id) }));
+	invalidations.push(queryClient.invalidateQueries({ queryKey: input.actor.kind === "personal" ? capxulKeys.accountBalance : capxulKeys.orgTreasury(toOrgId(input.actor.organizationId)) }));
+	await Promise.all(invalidations);
+}
+//#endregion
+//#region ../protocol/src/payments/request-finality.ts
+/** Only an authoritative failed-key response or confirmed durable closure resolves a key. */
+function isFinalPaymentRequestError(error) {
+	return error.details?.paymentRequestFinality === "closed" || error.code === "INVALID_INPUT" && error.details?.field === "requestKey" && error.details.paymentRequestFinality === "failed";
+}
+//#endregion
+//#region ../protocol/src/payments/attempt-locks.ts
+/** Prefix of the storage slot (and its locks) one payment intent's request key lives in. */
+const PAYMENT_REQUEST_KEY_SLOT_PREFIX = "capxul.payment.request-key.v3";
+function isPaymentRequestKeyState(value) {
+	return isRecord(value) && typeof value.key === "string" && Array.isArray(value.active) && value.active.every((attempt) => typeof attempt === "string") && typeof value.resolved === "boolean";
+}
+/** The lock one attempt holds for the life of its payment call. */
+function paymentAttemptLockName(slot, attemptId) {
+	return `${slot}:attempt:${attemptId}`;
+}
+/** The attempt ids whose locks are held for this slot right now, in any tab. */
+async function heldPaymentAttemptIds(manager, slot) {
+	const prefix = `${slot}:attempt:`;
+	return ((await manager.query()).held ?? []).map((lock) => lock.name).filter((name) => name?.startsWith(prefix) === true).map((name) => name.slice(prefix.length));
+}
+/** Hold the named lock until the returned release runs. Resolves once it is acquired. */
+async function holdPaymentAttemptLock(manager, name) {
+	let acquired;
+	let release;
+	const ready = new Promise((resolve) => {
+		acquired = resolve;
+	});
+	const held = manager.request(name, async () => {
+		acquired?.();
+		await new Promise((resolve) => {
+			release = resolve;
+		});
+	});
+	await Promise.race([ready, held.then(() => Promise.reject(/* @__PURE__ */ new Error("Payment attempt lock ended before acquisition")))]);
+	return () => {
+		release?.();
+		held.catch(() => void 0);
+	};
+}
+const attemptReleases = /* @__PURE__ */ new Set();
+let pagehideInstalled = false;
+/** Release the attempt's lock when the page goes away; the returned function forgets it. */
+function releasePaymentAttemptOnPagehide(release) {
+	attemptReleases.add(release);
+	if (!pagehideInstalled) {
+		pagehideInstalled = true;
+		window.addEventListener("pagehide", () => {
+			for (const releaseAttempt of attemptReleases) releaseAttempt();
+			attemptReleases.clear();
+		});
+	}
+	return () => attemptReleases.delete(release);
+}
+//#endregion
+//#region src/payments/payment-request-key.ts
+async function storageKey$1(operation, intent) {
+	return `${PAYMENT_REQUEST_KEY_SLOT_PREFIX}:${await fingerprintPaymentIntent({
+		operation,
+		intent
+	})}`;
+}
+function paymentLockManager() {
+	const manager = navigator.locks;
+	if (manager === void 0 || typeof manager.query !== "function") throw Errors.providerError("sdk-react", "paymentRequestKey", /* @__PURE__ */ new Error("Web Locks are required for payment request keys"));
+	return manager;
+}
+function readState(key) {
+	const stored = localStorage.getItem(key);
+	if (stored === null) return null;
+	const state = JSON.parse(stored);
+	if (!isPaymentRequestKeyState(state)) throw Errors.providerError("sdk-react", "paymentRequestKey", /* @__PURE__ */ new TypeError("Invalid payment request key state"));
+	return state;
+}
+async function beginPaymentRequestKey(operation, intent) {
+	let releaseAttemptLock;
+	let forgetPagehideRelease;
+	try {
+		const storageSlot = await storageKey$1(operation, intent);
+		const attemptId = `attempt_${crypto.randomUUID()}`;
+		const manager = paymentLockManager();
+		releaseAttemptLock = await holdPaymentAttemptLock(manager, paymentAttemptLockName(storageSlot, attemptId));
+		forgetPagehideRelease = releasePaymentAttemptOnPagehide(releaseAttemptLock);
+		const key = await manager.request(storageSlot, async () => {
+			let state = readState(storageSlot) ?? {
+				key: `pay_${Array.from(crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(16)), (byte) => byte.toString(16).padStart(2, "0")).join("")}`,
+				active: [],
+				resolved: false
+			};
+			const registered = state.active.includes(attemptId);
+			const active = await heldPaymentAttemptIds(manager, storageSlot);
+			if (!registered && active.every((id) => id === attemptId) && state.resolved) state = {
+				key: `pay_${crypto.randomUUID()}`,
+				active: [],
+				resolved: false
+			};
+			state.active = active;
+			localStorage.setItem(storageSlot, JSON.stringify(state));
+			return state.key;
+		});
+		let finished = false;
+		return {
+			key,
+			finish: async (succeeded) => {
+				if (finished) return;
+				try {
+					await manager.request(storageSlot, async () => {
+						const state = readState(storageSlot);
+						if (state === null || state.key !== key) return;
+						const attemptIndex = state.active.indexOf(attemptId);
+						if (attemptIndex < 0) return;
+						state.active.splice(attemptIndex, 1);
+						state.active = (await heldPaymentAttemptIds(manager, storageSlot)).filter((id) => id !== attemptId);
+						state.resolved = succeeded;
+						if (state.active.length === 0 && state.resolved) localStorage.removeItem(storageSlot);
+						else localStorage.setItem(storageSlot, JSON.stringify(state));
+					});
+					finished = true;
+				} finally {
+					forgetPagehideRelease?.();
+					releaseAttemptLock?.();
+				}
+			}
+		};
+	} catch (cause) {
+		forgetPagehideRelease?.();
+		releaseAttemptLock?.();
+		throw Errors.providerError("sdk-react", "paymentRequestKey", cause);
+	}
+}
+async function withPaymentRequestKey(operation, intent, work) {
+	const attempt = await beginPaymentRequestKey(operation, intent);
+	try {
+		const result = await work(attempt.key);
+		try {
+			await attempt.finish(true);
+		} catch {}
+		return result;
+	} catch (cause) {
+		try {
+			await attempt.finish(isCapxulError(cause) && isFinalPaymentRequestError(cause));
+		} catch {}
+		throw cause;
+	}
+}
+//#endregion
+//#region src/platform/reject-unresolved-actor.ts
+/**
+* Guard for mutation hooks whose variables carry an optional `actor` field
+* (`useCapxulPay`, `useCapxulAddDestination`,
+* `useCapxulRemoveDestination`). Mirrors `requireActorScope` on the query path:
+* an EXPLICITLY-passed `actor: undefined` (the `capxulOrgScope(notYetLoadedOrgId)`
+* footgun) must fail loudly rather than silently fall back to the personal
+* scope. Omitting the `actor` key entirely keeps the personal-scope default.
+*
+* Throws `CapxulError` code `INVALID_INPUT` with `details.field === "actor"`;
+* called inside an async mutationFn it surfaces as `mutation.error: CapxulError`.
+*/
+function rejectUnresolvedActor(variables, operation) {
+	if (Object.hasOwn(variables, "actor") && "actor" in variables && variables.actor === void 0) throw Errors.invalidInput("actor", `explicitly provided but undefined for ${operation} — actor scope not yet resolved; omit actor for the personal scope`);
+}
+//#endregion
+//#region src/payments/use-capxul-money.ts
+function useCapxulPay() {
+	const client = useCapxulClientOrNull();
+	const identity = useCapxulIdentityOrNull();
+	const actorId = identity?.phase === "authenticated" ? identity.session.authUserId : "signed-out";
+	const backendScope = client === null ? "pending" : `${client._internal.bootstrap.convexUrl}:${String(client._internal.bootstrap.chainId)}`;
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (input) => {
+			rejectUnresolvedActor(input, CAPXUL_OPERATIONS.payments.pay);
+			const bootstrappedClient = requireBootstrappedClient(client, CAPXUL_OPERATIONS.payments.pay);
+			return withPaymentRequestKey("personal-pay", {
+				actorId,
+				backendScope,
+				input
+			}, async (requestKey) => unwrapCapxulResult(await bootstrappedClient.payments.pay({
+				...input,
+				requestKey
+			})));
+		},
+		onSuccess: async (payment) => {
+			await invalidateMoneyState(queryClient, {
+				actor: { kind: "personal" },
+				payment
+			});
+		}
+	});
+}
+function useCapxulPayments(options) {
+	const client = useCapxulClientOrNull();
+	const identity = useCapxulIdentityOrNull();
+	return useQuery({
+		queryKey: accountKey(capxulKeys.payments, identity),
+		queryFn: async () => {
+			return unwrapCapxulResult(await requireBootstrappedClient(client, CAPXUL_OPERATIONS.payments.list).payments.list());
+		},
+		enabled: client !== null && identity !== null && isClaimed$1(identity) && (options?.enabled ?? true)
+	});
+}
+function useCapxulPayment(paymentId, options) {
+	const client = useCapxulClientOrNull();
+	const identity = useCapxulIdentityOrNull();
+	return useQuery({
+		queryKey: accountKey(capxulKeys.payment(paymentId), identity),
+		queryFn: async () => {
+			if (paymentId === void 0) throw Errors.invalidInput("paymentId", "required for payments.get");
+			return unwrapCapxulResult(await requireBootstrappedClient(client, CAPXUL_OPERATIONS.payments.get).payments.get(paymentId));
+		},
+		enabled: client !== null && paymentId !== void 0 && (options?.enabled ?? true)
+	});
+}
+//#endregion
+//#region src/payments/use-capxul-organization-payments.ts
+/**
+* `orgId` may be absent because a screen has no branded org id until its org
+* context loads (`OrgView.id` is the branded one). An absent id refuses the
+* mutation the way every other org read refuses one, rather than forcing a
+* `as OrgId` cast at the call site.
+*/
+function useCapxulOrganizationPay(orgId) {
+	const client = useCapxulClientOrNull();
+	const backendScope = client === null ? "pending" : `${client._internal.bootstrap.convexUrl}:${String(client._internal.bootstrap.chainId)}`;
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (input) => {
+			if (orgId === void 0) throw Errors.invalidInput("orgId", "required for useCapxulOrganizationPay");
+			const bootstrapped = requireBootstrappedClient(client, CAPXUL_OPERATIONS.organizationPayments.pay);
+			return withPaymentRequestKey("organization-pay", {
+				backendScope,
+				orgId,
+				...input
+			}, async (requestKey) => unwrapCapxulResult(await bootstrapped.org(orgId).payments.pay({
+				...input,
+				requestKey
+			})));
+		},
+		onSuccess: async (payment) => {
+			if (orgId === void 0) return;
+			return invalidateMoneyState(queryClient, {
+				actor: {
+					kind: "organization",
+					organizationId: orgId
+				},
+				payment
+			});
+		}
+	});
+}
+function useCapxulOrganizationPayBatch(orgId) {
+	const client = useCapxulClientOrNull();
+	const backendScope = client === null ? "pending" : `${client._internal.bootstrap.convexUrl}:${String(client._internal.bootstrap.chainId)}`;
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (input) => {
+			const bootstrapped = requireBootstrappedClient(client, CAPXUL_OPERATIONS.organizationPayments.payBatch);
+			return withPaymentRequestKey("organization-pay-batch", {
+				backendScope,
+				orgId,
+				...input
+			}, async (requestKey) => unwrapCapxulResult(await bootstrapped.org(orgId).payments.payBatch({
+				...input,
+				requestKey
+			})));
+		},
+		onSuccess: async (payments) => {
+			return Promise.all(payments.map((payment) => invalidateMoneyState(queryClient, {
+				actor: {
+					kind: "organization",
+					organizationId: orgId
+				},
+				payment
+			})));
+		}
+	});
+}
+//#endregion
+//#region src/payments/write-names-asset.ts
+/**
+* Identity law: "A payment names an asset or inherits it from an authorized
+* fact. Missing asset refuses." The rule was recorded in the retired
+* treasury-cut handoff (removed from the current tree by the exact-asset
+* contraction; its record survives in Git history).
+*
+* A Capxul payment writer takes `PaymentMoney` — a peg currency, a value and
+* `decimals` — and settles one fixed legacy token. No `AssetId` crosses that
+* seam, so a payment composed from a named position cannot name the asset it
+* moves: a position selected as USDT authorizes a different token.
+*
+* `false` until the writer takes the command's asset. The Send and Payroll
+* composers read this to refuse a submission rather than authorize a token the
+* person did not pick.
+*/
+function writeNamesAsset() {
+	return false;
+}
+//#endregion
+//#region src/platform/signer-status.ts
+const NO_SUBSCRIPTION = () => () => {};
+function useSignerStatus(client) {
+	const signer = client?.signer;
+	return useSyncExternalStore(useMemo(() => signer === void 0 ? NO_SUBSCRIPTION : (listener) => signer.subscribe(listener), [signer]), () => signer === void 0 ? "unknown" : signer.status(), () => "unknown");
+}
+//#endregion
+//#region src/payments/use-recipient-resolution.ts
+const EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+const PARTY_ID_RE = /^party_[0-9A-Za-z]+$/;
+const RESOLVE_DEBOUNCE_MS = 400;
+function parseRecipient(text) {
+	const trimmed = text.trim();
+	if (trimmed === "") return { status: "empty" };
+	if (PARTY_ID_RE.test(trimmed)) return {
+		status: "valid",
+		reference: {
+			kind: "party",
+			partyId: toPartyId(trimmed)
+		}
+	};
+	if (EVM_ADDRESS_RE.test(trimmed)) return {
+		status: "valid",
+		reference: {
+			kind: "address",
+			address: toEvmAddress(trimmed)
+		}
+	};
+	if (EMAIL_RE.test(trimmed)) return {
+		status: "valid",
+		reference: {
+			kind: "email",
+			email: trimmed.toLowerCase()
+		}
+	};
+	const handle = trimmed.replace(/^@/, "").toLowerCase();
+	if (HANDLE_RE.test(handle)) return {
+		status: "valid",
+		reference: {
+			kind: "handle",
+			handle
+		}
+	};
+	return { status: "invalid" };
+}
+function sameReference(left, right) {
+	return JSON.stringify(left) === JSON.stringify(right);
+}
+function publicRecipientValue(value) {
+	if (value === null) return null;
+	if (value.status === "known_party") return value.handle ?? value.label;
+	return value.status === "external_address" ? value.safeAddress : null;
+}
+function recipientStatus(parsed, settled, acknowledged) {
+	if (parsed.status === "empty" || parsed.status === "invalid") return parsed.status;
+	if (settled === null) return "checking";
+	if (!settled.ok) return settled.error.code === "INVALID_INPUT" ? "not-found" : "failed";
+	if (settled.value.status === "known_party") return "known-party";
+	if (settled.value.status === "new_email") return "new-email";
+	return acknowledged ? "external-ready" : "external-warning";
+}
+function useRecipientResolution(client, scope, organizationId) {
+	const [text, setText] = useState("");
+	const parsed = useMemo(() => parseRecipient(text), [text]);
+	const reference = parsed.status === "valid" ? parsed.reference : null;
+	const debouncedReference = useDebouncedValue(reference, RESOLVE_DEBOUNCE_MS);
+	const debouncedText = useDebouncedValue(text, RESOLVE_DEBOUNCE_MS);
+	const [outcome, setOutcome] = useState(null);
+	const [acknowledgedOutcome, setAcknowledgedOutcome] = useState(null);
+	const capturedAcknowledgement = useRef(null);
+	const change = useCallback((next) => {
+		if (next === text) return;
+		setAcknowledgedOutcome(null);
+		setOutcome(null);
+		setText(next);
+	}, [text]);
+	useEffect(() => {
+		if (debouncedReference === null || client === null) {
+			setOutcome(null);
+			return;
+		}
+		const controller = new AbortController();
+		setOutcome(null);
+		client.targets.resolve(debouncedReference, { signal: controller.signal }).then((result) => {
+			if (!controller.signal.aborted) setOutcome({
+				client,
+				scope,
+				text: debouncedText,
+				input: debouncedReference,
+				result
+			});
+		});
+		return () => controller.abort();
+	}, [
+		client,
+		scope,
+		debouncedReference,
+		debouncedText
+	]);
+	const settled = reference !== null && debouncedReference !== null && outcome !== null && outcome.client === client && outcome.scope === scope && outcome.text === text && sameReference(reference, debouncedReference) && sameReference(outcome.input, debouncedReference) ? outcome.result : null;
+	const status = recipientStatus(parsed, settled, acknowledgedOutcome === outcome);
+	const ready = settled?.ok === true && (settled.value.status !== "external_address" || status === "external-ready");
+	const value = settled?.ok === true ? settled.value : null;
+	const acknowledgeExternalAddress = useCallback(() => {
+		if (value?.status !== "external_address" || outcome === null) return;
+		setAcknowledgedOutcome(outcome);
+		if (capturedAcknowledgement.current === outcome) return;
+		capturedAcknowledgement.current = outcome;
+		client?._internal.captureExternalAddressAcknowledged(value.safeAddress, organizationId);
+	}, [
+		client,
+		organizationId,
+		value,
+		outcome
+	]);
+	return {
+		slice: {
+			value: text,
+			change,
+			status,
+			label: value?.label ?? null,
+			kind: value?.kind ?? null,
+			isCapxulAccount: value?.isCapxulAccount ?? null,
+			publicValue: publicRecipientValue(value),
+			requiresAcknowledgement: status === "external-warning",
+			acknowledgeExternalAddress
+		},
+		resolvedReference: ready && value !== null ? value.reference : null,
+		trimmed: text.trim()
+	};
+}
+//#endregion
+//#region src/payments/use-send-money.ts
+/**
+* One dropdown's selection. It reconciles whenever the held id is absent from
+* the option list — first mount AND a swap under a mounted root both land here
+* — and `select` narrows internally, so an id the caller does not hold is
+* ignored and no cast reaches app code.
+*/
+function useSelectedOption(options) {
+	const [selectedId, setSelectedId] = useState(null);
+	useEffect(() => {
+		if (!options.some((option) => option.id === selectedId)) setSelectedId(options[0]?.id ?? null);
+	}, [options, selectedId]);
+	const select = useCallback((id) => {
+		setSelectedId((current) => options.some((option) => option.id === id) ? id : current);
+	}, [options]);
+	return [options.find((option) => option.id === selectedId) ?? null, select];
+}
+function useSendMoney(input) {
+	const { actor, onSent, onFailed } = input;
+	const client = useCapxulClientOrNull();
+	const signerStatus = useSignerStatus(client);
+	const orgId = actor.kind === "organization" ? actor.orgId : void 0;
+	const meReading = useOrgMeReading(orgId);
+	const sourceOptions = useMemo(() => meReading.kind === "ready" ? meReading.me.budgets.map((budget) => ({ id: budget.id })) : [], [meReading]);
+	const [selectedSource, selectSource] = useSelectedOption(sourceOptions);
+	const balance = useCapxulAccountBalance({ enabled: actor.kind === "personal" });
+	const treasury = useCapxulOrgTreasury(orgId, { enabled: actor.kind === "organization" });
+	const accountQuery = actor.kind === "personal" ? balance : treasury;
+	const account = accountQuery.data ?? null;
+	const assetSelections = useMemo(() => assetSelectionsFromAccount(account), [account]);
+	const assetOptions = useMemo(() => assetSelections.map((selection) => selection.option), [assetSelections]);
+	const [selectedAssetOption, selectAsset] = useSelectedOption(assetOptions);
+	const selectedAssetMoney = useMemo(() => assetSelections.find((selection) => selection.option.id === selectedAssetOption?.id)?.money ?? null, [assetSelections, selectedAssetOption]);
+	const [amountText, setAmountText] = useState("");
+	const parsed = useMemo(() => selectedAssetMoney === null || amountText.trim() === "" ? null : parseAssetAmount(amountText, requireAsset(selectedAssetMoney.asset)), [amountText, selectedAssetMoney]);
+	const parsedMoney = parsed !== null && !isMoneyParseError(parsed) ? parsed : null;
+	const amountError = parsed !== null && isMoneyParseError(parsed) ? parsed.reason : null;
+	const recipient = useRecipientResolution(client, JSON.stringify([
+		actor.kind,
+		orgId,
+		account?.id
+	]), orgId);
+	const resolvedReference = recipient.resolvedReference;
+	const personalPay = useCapxulPay();
+	const organizationPay = useCapxulOrganizationPay(orgId);
+	const pay = actor.kind === "personal" ? personalPay : organizationPay;
+	const blockedReason = signerStatus !== "ready" ? "signer-not-ready" : actor.kind === "organization" && selectedSource === null ? "no-source" : selectedAssetOption === null ? "no-asset" : parsedMoney === null ? "amount-invalid" : resolvedReference === null ? "recipient-unresolved" : writeNamesAsset() ? null : "asset-unnamed";
+	const submitGate = useRef(false);
+	const submit = useCallback(() => {
+		if (blockedReason !== null || submitGate.current) return;
+		if (parsedMoney === null || resolvedReference === null) return;
+		const amount = parsedMoney;
+		const sentRecipient = recipient.trimmed;
+		const externalAddressAcknowledged = recipient.slice.status === "external-ready";
+		const callbacks = {
+			onSuccess: (payment) => onSent({
+				payment,
+				amount,
+				recipient: sentRecipient
+			}),
+			onError: (error) => onFailed(error),
+			onSettled: () => {
+				submitGate.current = false;
+			}
+		};
+		if (actor.kind === "personal") {
+			submitGate.current = true;
+			personalPay.mutate({
+				to: resolvedReference,
+				amount,
+				...externalAddressAcknowledged ? { externalAddressAcknowledged: true } : {}
+			}, callbacks);
+			return;
+		}
+		if (selectedSource === null) return;
+		submitGate.current = true;
+		organizationPay.mutate({
+			permissionId: selectedSource.id,
+			to: resolvedReference,
+			amount,
+			...externalAddressAcknowledged ? { externalAddressAcknowledged: true } : {}
+		}, callbacks);
+	}, [
+		actor.kind,
+		blockedReason,
+		onFailed,
+		onSent,
+		organizationPay,
+		parsedMoney,
+		personalPay,
+		recipient.trimmed,
+		recipient.slice.status,
+		resolvedReference,
+		selectedSource
+	]);
+	return {
+		source: {
+			options: sourceOptions,
+			selected: selectedSource,
+			select: selectSource,
+			error: meReading.kind === "unavailable" ? "read-failed" : null,
+			isPending: meReading.kind === "loading"
+		},
+		asset: {
+			options: assetOptions,
+			selected: selectedAssetOption,
+			select: selectAsset,
+			error: accountQuery.error !== null ? "read-failed" : null,
+			isPending: accountQuery.isPending && (actor.kind === "personal" || orgId !== void 0)
+		},
+		amount: {
+			value: amountText,
+			change: setAmountText,
+			error: amountError,
+			availableDisplay: selectedAssetOption?.availableDisplay ?? null
+		},
+		recipient: recipient.slice,
+		actions: {
+			submit,
+			isSubmitting: pay.isPending,
+			blocked: blockedReason !== null,
+			blockedReason
+		}
+	};
+}
+//#endregion
+//#region src/payments/send-money.tsx
+const SendMoneyContext = createContext(null);
+function useSendMoneyContext() {
+	const engine = useContext(SendMoneyContext);
+	if (engine === null) throw new Error("CapxulSendMoney parts must be used inside <CapxulSendMoney>");
+	return engine;
+}
+function Root$4({ actor, onSent, onFailed, children }) {
+	const engine = useSendMoney({
+		actor,
+		onSent,
+		onFailed
+	});
+	return /* @__PURE__ */ jsx(SendMoneyContext.Provider, {
+		value: engine,
+		children
+	});
+}
+function Source({ children }) {
+	return /* @__PURE__ */ jsx(Fragment, { children: children(useSendMoneyContext().source) });
+}
+function Asset$1({ children }) {
+	return /* @__PURE__ */ jsx(Fragment, { children: children(useSendMoneyContext().asset) });
+}
+function Amount({ children }) {
+	return /* @__PURE__ */ jsx(Fragment, { children: children(useSendMoneyContext().amount) });
+}
+function Recipient({ children }) {
+	return /* @__PURE__ */ jsx(Fragment, { children: children(useSendMoneyContext().recipient) });
+}
+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$4, {
+	Source,
+	Asset: Asset$1,
+	Amount,
+	Recipient,
+	Actions: Actions$1
+});
+//#endregion
+//#region src/permissions/use-capxul-permissions.ts
+function usePermissionMutation(orgId, operation) {
+	const client = useCapxulClientOrNull();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (input) => {
+			const methods = requireBootstrappedClient(client, CAPXUL_OPERATIONS.org.permissions[operation]).org(orgId).permissions;
+			return unwrapCapxulResult(await methods[operation](input));
+		},
+		onSuccess: () => queryClient.invalidateQueries({ queryKey: capxulKeys.orgPermissions(orgId) })
+	});
+}
+const useCapxulPermissionCreate = (orgId) => usePermissionMutation(orgId, "create");
+const useCapxulPermissionChange = (orgId) => usePermissionMutation(orgId, "change");
+const useCapxulPermissionAssign = (orgId) => usePermissionMutation(orgId, "assign");
+const useCapxulPermissionRevoke = (orgId) => usePermissionMutation(orgId, "revoke");
+const useCapxulPermissionReplace = (orgId) => usePermissionMutation(orgId, "replace");
+function useCapxulPermissions(orgId, options) {
+	const client = useCapxulClientOrNull();
+	const identity = useCapxulIdentityOrNull();
+	return useQuery({
+		queryKey: capxulKeys.orgPermissions(orgId),
+		queryFn: async () => {
+			return unwrapCapxulResult(await requireBootstrappedClient(client, CAPXUL_OPERATIONS.org.permissions.list).org(orgId).permissions.list());
+		},
+		enabled: client !== null && identity !== null && isClaimed$1(identity) && (options?.enabled ?? true)
+	});
+}
+function useCapxulPermission(orgId, permissionId) {
+	const client = useCapxulClientOrNull();
+	return useQuery({
+		queryKey: [...capxulKeys.orgPermissions(orgId), permissionId ?? "pending"],
+		queryFn: async () => {
+			if (permissionId === void 0) throw Errors.invalidInput("permissionId", "required for permissions.get");
+			return unwrapCapxulResult(await requireBootstrappedClient(client, CAPXUL_OPERATIONS.org.permissions.get).org(orgId).permissions.get(permissionId));
+		},
+		enabled: client !== null && permissionId !== void 0
+	});
+}
+//#endregion
+//#region src/activity/use-capxul-activity.ts
+function useCapxulActivity(params) {
+	const client = useCapxulClientOrNull();
+	const identity = useCapxulIdentityOrNull();
+	return useQuery({
+		queryKey: accountKey([...capxulKeys.activity, params ?? {}], identity),
+		queryFn: async () => {
+			return unwrapCapxulResult(await requireBootstrappedClient(client, CAPXUL_OPERATIONS.activity.items.list).activity.list(params));
+		},
+		enabled: client !== null && identity !== null && isClaimed$1(identity)
+	});
+}
+function useCapxulActivityDetail(reference, actor) {
+	const client = useCapxulClientOrNull();
+	const identity = useCapxulIdentityOrNull();
+	return useQuery({
+		queryKey: accountKey(capxulKeys.activityDetail(reference, actor), identity),
+		queryFn: async () => {
+			if (reference === void 0) throw Errors.invalidInput("reference", "required for activity.get");
+			return unwrapCapxulResult(await requireBootstrappedClient(client, CAPXUL_OPERATIONS.activity.items.get).activity.get(reference, actor === void 0 ? void 0 : { actor }));
+		},
+		enabled: client !== null && reference !== void 0 && identity !== null && isClaimed$1(identity)
+	});
+}
+function useCapxulAnnotateMovement() {
+	const client = useCapxulClientOrNull();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (input) => {
+			return unwrapCapxulResult(await requireBootstrappedClient(client, CAPXUL_OPERATIONS.activity.annotations.save).activity.annotate(input));
+		},
+		onSuccess: () => queryClient.invalidateQueries({ queryKey: capxulKeys.activity })
+	});
+}
+//#endregion
+//#region src/platform/as-capxul-error.ts
+/**
+* A caught failure as the `CapxulError` it is. Every query and mutation 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 toCapxulError(cause) {
+	return isCapxulError(cause) ? cause : Errors.unknown(cause);
+}
+/** TanStack types a query error as `Error | null`: the same, with no error passed through. */
+function asCapxulError(error) {
+	return error === null ? null : toCapxulError(error);
+}
+//#endregion
+//#region src/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/activity/detail.ts
+function detailDocuments(detail) {
+	return detail === null ? [] : detail.kind === "payment" ? detail.payment.documents : detail.documents;
+}
+/**
+* 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 identity = useCapxulIdentityOrNull();
+	const enabled = useActivityEnabled() && reference !== void 0;
+	const detail = useQuery({
+		queryKey: accountKey(capxulKeys.activityDetail(reference, actor), identity),
+		queryFn: async ({ signal }) => {
+			if (reference === void 0) throw Errors.invalidInput("reference", "required for activity.get");
+			return unwrapCapxulResult(await requireBootstrappedClient(client, CAPXUL_OPERATIONS.activity.items.get).activity.get(reference, {
+				...actor === void 0 ? {} : { actor },
+				signal
+			}));
+		},
+		enabled
+	});
+	const documents = detailDocuments(detail.data ?? null);
+	const [selected, setSelected] = useState(null);
+	const selectedDocument = (selected === null ? void 0 : documents.find((doc) => doc.documentHash === selected.documentHash && doc.contentHash === selected.contentHash)) ?? documents.find((doc) => doc.role === "instruction") ?? documents.find((doc) => doc.role === "movement") ?? documents[0] ?? null;
+	const pending = useRef(/* @__PURE__ */ new Set());
+	const mounted = useRef(true);
+	useEffect(() => {
+		mounted.current = true;
+		const reads = pending.current;
+		return () => {
+			mounted.current = false;
+			for (const read of reads) read.abort();
+			reads.clear();
+		};
+	}, []);
+	const selectDocument = useCallback((ref) => {
+		if (!documents.some((doc) => doc.documentHash === ref.documentHash && doc.contentHash === ref.contentHash)) throw Errors.invalidInput("documentHash", "document not found");
+		for (const read of pending.current) read.abort();
+		pending.current.clear();
+		setIsOpeningDocument(false);
+		setSelected({
+			documentHash: ref.documentHash,
+			contentHash: ref.contentHash
+		});
+	}, [documents]);
+	const [isOpeningDocument, setIsOpeningDocument] = useState(false);
+	const readDocument = useCallback(async (download) => {
+		const operation = download ? CAPXUL_OPERATIONS.activity.documents.get : CAPXUL_OPERATIONS.activity.documents.render;
+		if (!mounted.current) throw Errors.cancelled({ operation });
+		if (reference === void 0 || selectedDocument === null) throw Errors.invalidInput("documentHash", "no document on this row");
+		const controller = new AbortController();
+		pending.current.add(controller);
+		setIsOpeningDocument(true);
+		try {
+			const bootstrapped = requireBootstrappedClient(client, download ? CAPXUL_OPERATIONS.activity.documents.get : CAPXUL_OPERATIONS.activity.documents.render);
+			const pair = {
+				documentHash: selectedDocument.documentHash,
+				contentHash: selectedDocument.contentHash
+			};
+			const options = { signal: controller.signal };
+			const result = download ? await bootstrapped.paymentDocuments.get(pair, options) : await bootstrapped.paymentDocuments.render(pair, options);
+			if (controller.signal.aborted) throw Errors.cancelled({ operation });
+			return unwrapCapxulResult(result);
+		} finally {
+			pending.current.delete(controller);
+			if (!controller.signal.aborted) setIsOpeningDocument(pending.current.size > 0);
+		}
+	}, [
+		client,
+		selectedDocument,
+		reference
+	]);
+	const renderDocument = useCallback(async () => {
+		const result = await readDocument(false);
+		if (!("html" in result)) throw Errors.invalidInput("documentHash", "invalid document render");
+		return result;
+	}, [readDocument]);
+	const downloadDocument = useCallback(async () => {
+		const result = await readDocument(true);
+		if (!("bytesBase64" in result)) throw Errors.invalidInput("documentHash", "invalid document download");
+		return result;
+	}, [readDocument]);
+	const [typed, setTyped] = useState(null);
+	const annotate = useCapxulAnnotateMovement();
+	const saveMemo = useCallback(async () => {
+		if (reference === void 0 || typed === null) return { ok: true };
+		try {
+			await annotate.mutateAsync({
+				...actor === void 0 ? {} : { actor },
+				reference,
+				memo: typed
+			});
+			return { ok: true };
+		} catch (error) {
+			return {
+				ok: false,
+				error: toCapxulError(error)
+			};
+		}
+	}, [
+		actor,
+		annotate,
+		reference,
+		typed
+	]);
+	return {
+		...detail.data?.kind === "payment" ? { payment: {
+			status: detail.data.payment.status,
+			...detail.data.payment.execution === void 0 ? {} : { execution: detail.data.payment.execution }
+		} } : {},
+		documents,
+		selectedDocument,
+		selectDocument,
+		renderDocument,
+		downloadDocument,
+		isOpeningDocument,
+		memo: typed ?? detail.data?.annotation?.memo ?? "",
+		setMemo: setTyped,
+		saveMemo,
+		isSavingMemo: annotate.isPending,
+		isLoading: enabled && detail.isLoading,
+		error: asCapxulError(detail.error) ?? annotate.error ?? null
+	};
+}
+//#endregion
+//#region src/activity/summary.ts
+const DAY_MS = 864e5;
+const display = (money) => money === null ? null : formatMoney(money);
+/**
+* `"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;
+}
+/**
+* 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 identity = useCapxulIdentityOrNull();
+	const enabled = useActivityEnabled();
+	const range = resolveWindow(window, useUtcDay(window === "last30days") * DAY_MS);
+	const summary = useQuery({
+		queryKey: accountKey(capxulKeys.activitySummary(actor, range), identity),
+		queryFn: async () => {
+			const params = {};
+			if (actor !== void 0) params.actor = actor;
+			if (range !== void 0) params.window = range;
+			const result = unwrapCapxulResult(await requireBootstrappedClient(client, CAPXUL_OPERATIONS.activity.items.summary).activity.summary(params));
+			return {
+				...result,
+				valuation: valueActivitySummary(result.totals)
+			};
+		},
+		enabled
+	});
+	const totals = summary.data?.totals;
+	const isLoading = summary.isLoading;
+	if (summary.data === void 0 || totals === void 0 || totals.length === 0 || isLoading) return {
+		currency: null,
+		moneyIn: null,
+		moneyOut: null,
+		net: null,
+		pending: null,
+		unrated: [],
+		count: summary.data?.count ?? 0,
+		isLoading,
+		error: asCapxulError(summary.error),
+		...summary.data?.readWarning === void 0 ? {} : { readWarning: summary.data.readWarning }
+	};
+	const valuation = summary.data.valuation;
+	return {
+		currency: valuation.moneyIn?.currency ?? null,
+		moneyIn: display(valuation.moneyIn),
+		moneyOut: display(valuation.moneyOut),
+		net: display(valuation.net),
+		pending: display(valuation.pending),
+		unrated: valuation.unrated,
+		count: summary.data?.count ?? 0,
+		isLoading,
+		error: asCapxulError(summary.error),
+		...summary.data?.readWarning === void 0 ? {} : { readWarning: summary.data.readWarning }
+	};
+}
+//#endregion
+//#region src/activity/rows.ts
+/**
+* A Movement's phase is DERIVED, not asserted: `movementItems` returns `null`
+* for any Movement whose `canonicalState` is not `"included"`
+* (`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 = formatAssetAmount(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: assetSymbolFor(item.amount.asset),
+		createdAt: item.createdAt,
+		classification: item.classification,
+		phase: MOVEMENT_PHASE,
+		receipt: item.receipt
+	};
+	const reference = actor === void 0 ? {
+		kind: "payment",
+		id: item.id
+	} : {
+		kind: "payment",
+		id: item.id,
+		actor
+	};
+	return {
+		kind: "payment",
+		...item.execution === void 0 ? {} : { execution: item.execution },
+		reference,
+		direction: item.direction,
+		counterpartyLabel: item.counterpartyLabel,
+		amountDisplay,
+		signedAmountDisplay,
+		currency: assetSymbolFor(item.amount.asset),
+		createdAt: item.createdAt,
+		ledgerKind: item.ledgerKind,
+		paymentType: item.paymentType,
+		status: item.status,
+		phase: item.execution?.notSent ? {
+			...paymentPhase(item.status),
+			needsAction: item.direction !== "in"
+		} : 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/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$1(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$1(COLUMNS)];
+	for (const item of items) {
+		const row = toActivityRow(item, actor);
+		if (!matchesSearch(row, search)) continue;
+		records.push(record$1([
+			new Date(row.createdAt).toISOString(),
+			row.kind,
+			row.kind === "payment" ? row.paymentType : row.classification,
+			row.counterpartyLabel,
+			row.direction,
+			item.amount.value,
+			assetSymbolFor(item.amount.asset),
+			row.kind === "payment" ? row.execution?.notSent ? "not_sent" : row.execution?.status === "unresolved" ? "verifying" : row.status : "",
+			row.reference.id,
+			row.receipt?.transactionHash ?? ""
+		]));
+	}
+	return {
+		text: records.join("\r\n"),
+		rowCount: records.length - 1
+	};
+}
+//#endregion
+//#region src/activity/use-csv-export.ts
+/**
+* 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 = 100;
+const EXPORT_PAGE_CEILING = 50;
+/** The activity engine's CSV export: every page of one export is one attempt. */
+function useCsvExport(input) {
+	const { actor, client, listParams, searchText } = input;
+	const [isExporting, setIsExporting] = useState(false);
+	return {
+		toCsv: useCallback(async (options) => {
+			setIsExporting(true);
+			const controls = toInvocationControls(toInvocationOptions(options));
+			try {
+				const bootstrapped = requireBootstrappedClient(client, CAPXUL_OPERATIONS.activity.items.list);
+				const items = [];
+				let readWarning;
+				let cursor;
+				for (let page = 0; page < EXPORT_PAGE_CEILING; page += 1) {
+					const result = unwrapCapxulResult(await bootstrapped.activity.list(listParams(cursor, EXPORT_PAGE_SIZE), controls));
+					readWarning ??= result.readWarning;
+					items.push(...result.items);
+					cursor = result.nextCursor ?? void 0;
+					if (cursor === void 0) break;
+				}
+				return {
+					...buildCsv(items, actor, searchText),
+					truncated: cursor !== void 0,
+					...readWarning === void 0 ? {} : { readWarning }
+				};
+			} finally {
+				setIsExporting(false);
+			}
+		}, [
+			actor,
+			client,
+			listParams,
+			searchText
+		]),
+		isExporting
+	};
+}
+//#endregion
+//#region src/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;
+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 identity = useCapxulIdentityOrNull();
+	const account = actingAccount(identity);
+	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 selectedRetry = useRef(void 0);
+	const takeSelectedRetry = useCallback(() => {
+		const attempt = selectedRetry.current;
+		selectedRetry.current = void 0;
+		return toInvocationControls(attempt);
+	}, []);
+	const query = useInfiniteQuery({
+		queryKey: accountKey([
+			...capxulKeys.activity,
+			"list",
+			actor ?? "self",
+			limit,
+			filter ?? "none"
+		], identity),
+		queryFn: async ({ pageParam }) => {
+			return unwrapCapxulResult(await requireBootstrappedClient(client, CAPXUL_OPERATIONS.activity.items.list).activity.list(listParams(pageParam, limit), takeSelectedRetry()));
+		},
+		initialPageParam: void 0,
+		getNextPageParam: (last) => last.nextCursor ?? void 0,
+		enabled
+	});
+	const queryClient = useQueryClient();
+	useEffect(() => {
+		if (!enabled || client === null) return;
+		let stop;
+		let cancelled = false;
+		client.activity.subscribe(() => {
+			if (cancelled) return;
+			queryClient.invalidateQueries({ queryKey: capxulKeys.activity });
+		}, actor === void 0 ? void 0 : { actor }).then((result) => {
+			if (!result.ok) return;
+			if (cancelled) result.value();
+			else stop = result.value;
+		});
+		return () => {
+			cancelled = true;
+			stop?.();
+		};
+	}, [
+		account,
+		actor,
+		client,
+		enabled,
+		queryClient
+	]);
+	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 emptyContinuation = pages?.at(-1)?.items.length === 0 && hasNextPage && query.error === null;
+	useEffect(() => {
+		if (enabled && emptyContinuation && !isFetchingNextPage) fetchNextPage();
+	}, [
+		enabled,
+		emptyContinuation,
+		fetchNextPage,
+		isFetchingNextPage,
+		pages
+	]);
+	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 csv = useCsvExport({
+		client,
+		actor,
+		searchText,
+		listParams
+	});
+	const clear = useCallback(() => {
+		setKind(void 0);
+		setDirection(void 0);
+		setStatus([]);
+	}, []);
+	const retry = useCallback((options) => {
+		selectedRetry.current = toInvocationOptions(options);
+		refetch();
+		queryClient.invalidateQueries({
+			queryKey: capxulKeys.activitySummary(actor).slice(0, -1),
+			predicate: (cached) => cached.queryKey.at(-1) === accountKey([], identity)[0]
+		});
+	}, [
+		actor,
+		identity,
+		queryClient,
+		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 || rows.length === 0 && emptyContinuation,
+			error: asCapxulError(query.error),
+			retry,
+			observedAt: pages === void 0 ? null : pages[pages.length - 1]?.observedAt ?? null,
+			...pages?.some((page) => page.readWarning === "indexer-unavailable") ? { readWarning: "indexer-unavailable" } : {}
+		},
+		loadMore: {
+			hasMore: hasNextPage,
+			loadMore,
+			isLoadingMore: isFetchingNextPage,
+			sentinelRef
+		},
+		csv
+	};
+}
+//#endregion
+//#region src/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$3({ 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$3({ 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();
+	const identity = useCapxulIdentityOrNull();
+	return /* @__PURE__ */ jsx(DetailInstance, {
+		actor,
+		reference,
+		children
+	}, JSON.stringify(accountKey([activityDetailKey(actor, reference)], identity)));
+}
+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$3, {
+	Summary: Summary$3,
+	Filters,
+	Search,
+	Rows,
+	LoadMore,
+	Detail,
+	Export
+});
+//#endregion
+//#region src/media/use-capxul-image-upload.ts
+/**
+* #1061 / ADR-0014: the whole upload→record sequence as one mutation —
+* upload the blob, then bind the returned storage id to the profile image or
+* the org logo. The url is the resolved serving URL (re-read from queries,
+* never persisted by consumers).
+*/
+function useCapxulImageUpload() {
+	const client = useCapxulClientOrNull();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async ({ blob, target }) => {
+			const media = requireBootstrappedClient(client, CAPXUL_OPERATIONS.media.uploadImage).media;
+			const uploaded = unwrapCapxulResult(await media.uploadImage(blob));
+			if (target.kind === "profile") return { url: unwrapCapxulResult(await media.setProfileImage({ storageId: uploaded.storageId })).imageUrl };
+			return { url: unwrapCapxulResult(await media.setOrgLogo({
+				orgId: target.orgId,
+				storageId: uploaded.storageId
+			})).logoUrl };
+		},
+		onSuccess: async (_value, input) => {
+			await queryClient.invalidateQueries({ queryKey: input.target.kind === "profile" ? capxulKeys.profile : capxulKeys.orgs });
+		}
+	});
+}
+//#endregion
+//#region src/media/use-capxul-upload-image.ts
+/**
+* #1955: upload only. Hands back the storage id for a CREATE call to carry
+* (`ProfileDetails.imageStorageId`, `OrganizationDetails.logoStorageId`).
+*
+* `useCapxulImageUpload` is upload+bind and stays as it is for the settings
+* pages. It cannot serve onboarding: the row it binds to does not exist yet.
+* Nothing is bound here, so nothing is invalidated either — the create call
+* that carries the id owns the cache change.
+*/
+function useCapxulUploadImage() {
+	const client = useCapxulClientOrNull();
+	return useMutation({ mutationFn: async (blob) => {
+		return { storageId: unwrapCapxulResult(await requireBootstrappedClient(client, CAPXUL_OPERATIONS.media.uploadImage).media.uploadImage(blob)).storageId };
+	} });
+}
+//#endregion
+//#region src/parties/use-contacts.ts
+/** One captured snapshot, or nothing — never a fabricated empty options object. */
+const carry$1 = (options) => options === void 0 ? {} : { options };
+function useContacts(input) {
+	const { actor, onAdded, onFailed } = input;
+	const client = useCapxulClientOrNull();
+	const queryClient = useQueryClient();
+	const orgId = actor.kind === "organization" ? actor.orgId : void 0;
+	const scope = actor.kind === "personal" ? "personal" : orgId ?? "pending";
+	const refusal = actor.kind === "organization" && orgId === void 0 ? "org-unavailable" : null;
+	const book = useMemo(() => addressBookOf(client, actor.kind, orgId), [
+		client,
+		actor.kind,
+		orgId
+	]);
+	const invalidate = useCallback(() => queryClient.invalidateQueries({ queryKey: capxulKeys.contacts(scope) }), [queryClient, scope]);
+	const writeMutate = useMutation({
+		mutationFn: async (command) => {
+			const target = requireBook(book, `addressBook.${command.kind}`);
+			const controls = toInvocationControls(command.options);
+			return unwrapCapxulResult(command.kind === "rename" ? await target.label({
+				entryId: command.id,
+				label: command.name
+			}, controls) : command.kind === "hide" ? await target.hide(command.id, controls) : await target.unhide(command.id, controls));
+		},
+		onSettled: invalidate,
+		onError: (error, command) => onFailed(error, command.options)
+	}).mutate;
+	const [value, setValue] = useState("");
+	const [addError, setAddError] = useState(null);
+	const addContact = useMutation({
+		mutationFn: async (command) => unwrapCapxulResult(await requireBook(book, CAPXUL_OPERATIONS.parties.contacts.add).add({ ref: command.ref }, toInvocationControls(command.options))),
+		onSettled: invalidate
+	});
+	const addMutate = addContact.mutate;
+	const blockedReason = refusal !== null ? "org-unavailable" : value.trim() === "" ? "empty" : null;
+	const submitGate = useRef(false);
+	const submit = useCallback((options) => {
+		if (blockedReason !== null || submitGate.current) return;
+		const attempt = toInvocationOptions(options);
+		submitGate.current = true;
+		setAddError(null);
+		addMutate({
+			ref: refFromTypedText(value),
+			...carry$1(attempt)
+		}, {
+			onSuccess: (entry) => {
+				setValue("");
+				onAdded(toContact(entry), attempt);
+			},
+			onError: (error) => {
+				setAddError(error.code === "INVALID_INPUT" ? "unresolved" : "failed");
+				onFailed(error, attempt);
+			},
+			onSettled: () => {
+				submitGate.current = false;
+			}
+		});
+	}, [
+		addMutate,
+		blockedReason,
+		onAdded,
+		onFailed,
+		value
+	]);
+	const change = useCallback((text) => {
+		setValue(text);
+		setAddError(null);
+	}, []);
+	return {
+		book,
+		scope,
+		refusal,
+		rename: useCallback((id, name, options) => writeMutate({
+			kind: "rename",
+			id,
+			name,
+			...carry$1(toInvocationOptions(options))
+		}), [writeMutate]),
+		hide: useCallback((id, options) => writeMutate({
+			kind: "hide",
+			id,
+			...carry$1(toInvocationOptions(options))
+		}), [writeMutate]),
+		unhide: useCallback((id, options) => writeMutate({
+			kind: "unhide",
+			id,
+			...carry$1(toInvocationOptions(options))
+		}), [writeMutate]),
+		add: {
+			value,
+			change,
+			submit,
+			isSubmitting: addContact.isPending,
+			blocked: blockedReason !== null,
+			blockedReason,
+			error: addError
+		}
+	};
+}
+/**
+* The read every part stands on. Two placements with the same `show` share one
+* query key, so React Query issues ONE request for them.
+*/
+function useContactsList(engine, options) {
+	const identity = useCapxulIdentityOrNull();
+	const includeHidden = options.show === "all";
+	const { book, refusal } = engine;
+	const query = useQuery({
+		queryKey: accountKey(capxulKeys.contactsList(engine.scope, includeHidden), identity),
+		queryFn: async () => unwrapCapxulResult(await requireBook(book, CAPXUL_OPERATIONS.parties.contacts.list).list({ includeHidden })).items,
+		enabled: book !== null
+	});
+	const reason = refusal ?? (query.isError ? "unavailable" : query.data === void 0 ? "loading" : null);
+	const entries = query.data;
+	const { limit } = options;
+	const { rename, hide, unhide } = engine;
+	return {
+		rows: useMemo(() => {
+			if (entries === void 0) return [];
+			return (limit === void 0 ? entries : entries.slice(0, limit)).map((entry) => Object.assign(toContact(entry), {
+				initials: initialsOf(entry.label),
+				rename: (name, attempt) => rename(entry.id, name, attempt),
+				hide: (attempt) => hide(entry.id, attempt),
+				unhide: (attempt) => unhide(entry.id, attempt)
+			}));
+		}, [
+			entries,
+			hide,
+			limit,
+			rename,
+			unhide
+		]),
+		isLoading: reason === "loading",
+		reason
+	};
+}
+/** Counts over the same visible read `.List` uses — one request, two parts. */
+function useContactsSummary(engine) {
+	const { rows, isLoading, reason } = useContactsList(engine, {});
+	const settled = reason === null;
+	return {
+		total: settled ? rows.length : null,
+		activeCount: settled ? rows.filter((row) => row.relationship.includes("paid")).length : null,
+		isLoading,
+		reason
+	};
+}
+function addressBookOf(client, kind, orgId) {
+	if (client === null) return null;
+	if (kind === "personal") return client.account.addressBook;
+	return orgId === void 0 ? null : client.org(orgId).addressBook;
+}
+function requireBook(book, method) {
+	if (book === null) throw Errors.wrongState({
+		method,
+		currentState: "bootstrapping",
+		validStates: ["ready"]
+	});
+	return book;
+}
+function toContact(entry) {
+	return {
+		id: entry.id,
+		name: entry.label,
+		relationship: entry.relationship,
+		hidden: entry.hidden,
+		lastActivityAt: entry.lastActivityAt
+	};
+}
+/**
+* One typed field, both shapes. A leading `@` names a handle; an `@` anywhere
+* else names an email — what the app already builds for Quick Pay, and what the
+* backend resolver already accepts.
+*/
+function refFromTypedText(text) {
+	const trimmed = text.trim();
+	return trimmed.includes("@") && !trimmed.startsWith("@") ? {
+		kind: "email",
+		email: trimmed
+	} : {
+		kind: "handle",
+		handle: trimmed.replace(/^@/, "")
+	};
+}
+/** First letters of the first two words, uppercased. */
+function initialsOf(name) {
+	return name.trim().split(/\s+/).slice(0, 2).map((word) => word.charAt(0).toUpperCase()).join("");
+}
+//#endregion
+//#region src/parties/contacts.tsx
+const ContactsContext = createContext(null);
+function useContactsContext() {
+	const engine = useContext(ContactsContext);
+	if (engine === null) throw new Error("CapxulContacts parts must be used inside <CapxulContacts>");
+	return engine;
+}
+function Root$2({ actor, onAdded, onFailed, children }) {
+	const engine = useContacts({
+		actor,
+		onAdded,
+		onFailed
+	});
+	return /* @__PURE__ */ jsx(ContactsContext.Provider, {
+		value: engine,
+		children
+	});
+}
+function Summary$2({ children }) {
+	return /* @__PURE__ */ jsx(Fragment, { children: children(useContactsSummary(useContactsContext())) });
+}
+function List({ limit, show, children }) {
+	return /* @__PURE__ */ jsx(Fragment, { children: children(useContactsList(useContactsContext(), {
+		limit,
+		show
+	})) });
+}
+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$2, {
+	Summary: Summary$2,
+	List,
+	Add
+});
+//#endregion
+//#region src/payroll/draft-decoding.ts
+function decodeDraft(value, scope) {
+	const row = record(value);
+	const asset = record(row.asset);
+	const input = record(row.input);
+	const period = record(input.period);
+	if (row.version !== 1 || row.scope !== scope || typeof asset.currency !== "string" || !/^[A-Z][A-Z0-9]{1,11}$/u.test(asset.currency) || typeof asset.decimals !== "number" || !Number.isInteger(asset.decimals) || asset.decimals < 0 || asset.decimals > 255 || typeof period.start !== "number" || !Number.isSafeInteger(period.start) || period.start <= 0 || period.end !== period.start || !Array.isArray(input.items) || input.items.length === 0) throw Errors.invalidInput("payrollDraft", "Invalid run draft");
+	const items = input.items.map((raw) => {
+		const item = record(raw);
+		const to = record(item.to);
+		const amount = record(item.amount);
+		const partyId = toPartyId(identifier(item.partyId));
+		if (to.kind !== "party" || to.partyId !== partyId || item.gross !== item.net || typeof amount.asset !== "string" || typeof amount.value !== "string" || "currency" in item || "decimals" in item || !Array.isArray(item.adjustments) || item.adjustments.length !== 0) throw Errors.invalidInput("payrollDraft", "Invalid draft recipient");
+		const net = minorAmount(item.net);
+		const selectedAsset = requireAsset(toAssetId(identifier(amount.asset)));
+		const selectedAmount = {
+			asset: selectedAsset.assetId,
+			value: amount.value
+		};
+		try {
+			if (toRaw(selectedAmount, selectedAsset).toString() !== net) throw Errors.invalidInput("payrollDraft", "Draft payout units differ from net");
+		} catch {
+			throw Errors.invalidInput("payrollDraft", "Invalid draft payout amount");
+		}
+		return {
+			to: {
+				kind: "party",
+				partyId
+			},
+			partyId,
+			amount: selectedAmount,
+			gross: net,
+			net,
+			adjustments: []
+		};
+	});
+	if (new Set(items.map((item) => item.partyId)).size !== items.length) throw Errors.invalidInput("payrollDraft", "Duplicate draft recipient");
+	const exactAsset = requireAsset(toAssetId(identifier(asset.id)));
+	if (input.asset !== exactAsset.assetId || items.some((item) => item.amount.asset !== exactAsset.assetId)) throw Errors.invalidInput("payrollDraft", "Draft item asset does not match the run asset");
+	return {
+		version: 1,
+		scope,
+		asset: {
+			id: identifier(asset.id),
+			currency: asset.currency,
+			decimals: asset.decimals
+		},
+		input: {
+			permissionId: identifier(input.permissionId),
+			asset: exactAsset.assetId,
+			period: {
+				start: period.start,
+				end: period.start
+			},
+			items,
+			...input.requestKey === void 0 ? {} : { requestKey: identifier(input.requestKey) }
+		}
+	};
+}
+//#endregion
+//#region src/payroll/run-draft.ts
+function record(value) {
+	if (!isRecord(value)) throw Errors.invalidInput("payrollDraft", "Invalid run draft");
+	return value;
+}
+/**
+* A draft-scoped opaque key. `/` is in the class so `asset.id` can be the
+* canonical CAIP-19 `AssetId` (`eip155:<chainId>/erc20:<address>`): the draft
+* records WHICH asset was authorized, and a symbol is not an identity
+* (ADR-0028 R3). The field never reaches the backend — only `input` is sent.
+*/
+function identifier(value) {
+	if (typeof value !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/u.test(value)) throw Errors.invalidInput("payrollDraft", "Invalid draft identifier");
+	return value;
+}
+function minorAmount(value) {
+	if (typeof value !== "string" || !/^\d+$/u.test(value) || BigInt(value) <= 0n) throw Errors.invalidInput("payrollDraft", "Invalid draft amount");
+	return value;
+}
+function runDraftError(cause) {
+	return cause instanceof CapxulError ? cause : Errors.providerError("sdk-react", "payrollDraft", cause);
+}
+function storageKey(scope) {
+	return `capxul.payroll.run-draft.v1:${scope}`;
+}
+function readRunDraft(scope) {
+	try {
+		const raw = localStorage.getItem(storageKey(scope));
+		if (raw === null) return null;
+		let value;
+		try {
+			value = JSON.parse(raw);
+		} catch {
+			throw Errors.invalidInput("payrollDraft", "Invalid run draft JSON");
+		}
+		return decodeDraft(value, scope);
+	} catch (cause) {
+		throw runDraftError(cause);
+	}
+}
+function sameDraft(left, right) {
+	const { requestKey: _leftKey, ...leftInput } = left.input;
+	const { requestKey: _rightKey, ...rightInput } = right.input;
+	return left.scope === right.scope && JSON.stringify(left.asset) === JSON.stringify(right.asset) && JSON.stringify(leftInput) === JSON.stringify(rightInput);
+}
+/** Hold the draft across the Core call, including component unmount. A reload releases the native lock. */
+async function executeRunDraft(candidate, work) {
+	try {
+		if (navigator.locks === void 0) throw Errors.invalidInput("payrollDraft", "Web Locks are required for run drafts");
+		return await navigator.locks.request(storageKey(candidate.scope), { ifAvailable: true }, async (lock) => {
+			if (lock === null) throw Errors.wrongState({
+				method: CAPXUL_OPERATIONS.payroll.runs.authorize,
+				currentState: "run-in-flight",
+				validStates: ["run-idle"]
+			});
+			let draft = readRunDraft(candidate.scope) ?? decodeDraft(candidate, candidate.scope);
+			if (!sameDraft(draft, candidate)) throw Errors.wrongState({
+				method: CAPXUL_OPERATIONS.payroll.runs.authorize,
+				currentState: "unresolved-run-draft",
+				validStates: ["resolved-run-draft"]
+			});
+			localStorage.setItem(storageKey(draft.scope), JSON.stringify(draft));
+			const clear = () => {
+				const stored = readRunDraft(draft.scope);
+				if (stored === null || !sameDraft(stored, draft) || stored.input.requestKey !== draft.input.requestKey) throw Errors.invalidInput("payrollDraft", "Run draft changed during submission");
+				localStorage.removeItem(storageKey(draft.scope));
+			};
+			const run = await work(draft, (key) => {
+				const next = decodeDraft({
+					...draft,
+					input: {
+						...draft.input,
+						requestKey: key
+					}
+				}, draft.scope);
+				localStorage.setItem(storageKey(draft.scope), JSON.stringify(next));
+				draft = next;
+			}, clear);
+			try {
+				clear();
+			} catch {}
+			return run;
+		});
+	} catch (cause) {
+		throw runDraftError(cause);
+	}
+}
+/** Persistence becomes active only in a payable composer, never in the group editor. */
+function useRunDraft(client, orgId, apply) {
+	const identity = useCapxulIdentityOrNull();
+	const ownerId = identity?.phase === "authenticated" ? identity.session.authUserId : null;
+	const draftScope = client === null || ownerId === null || orgId === void 0 ? null : JSON.stringify([
+		client._internal.bootstrap.convexUrl,
+		client._internal.bootstrap.chainId,
+		ownerId,
+		orgId
+	]);
+	const currentScope = useRef(draftScope);
+	currentScope.current = draftScope;
+	const [active, setActive] = useState(false);
+	const activateDraft = useCallback(() => setActive(true), []);
+	const [restoredScope, setRestoredScope] = useState(null);
+	const [stored, setDraft] = useState(null);
+	const [draftError, setDraftError] = useState(null);
+	const draft = active && stored?.scope === draftScope ? stored : null;
+	const restorationPending = active && (draftScope === null || restoredScope !== draftScope);
+	const restoreDraft = useCallback((scope) => {
+		try {
+			const restored = readRunDraft(scope);
+			setDraft(restored);
+			setDraftError(null);
+			if (restored !== null) apply(restored);
+		} catch (cause) {
+			setDraft(null);
+			setDraftError(runDraftError(cause));
+		}
+		setRestoredScope(scope);
+	}, [apply]);
+	useEffect(() => {
+		if (active && draftScope !== null) restoreDraft(draftScope);
+	}, [
+		active,
+		draftScope,
+		restoreDraft
+	]);
+	return {
+		draftScope,
+		currentScope,
+		draft,
+		draftError,
+		restorationPending,
+		activateDraft,
+		restoreDraft,
+		setDraft,
+		recovery: !active || restorationPending ? "restoring" : draftError !== null ? "unavailable" : draft !== null ? "required" : "none",
+		draftBlocked: !active || restorationPending || draftError !== null
+	};
+}
+//#endregion
+//#region src/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
+* (`parties.contacts.list`). 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 identity = useCapxulIdentityOrNull();
+	const query = useQuery({
+		queryKey: accountKey(capxulKeys.contactsList(orgId ?? "pending", false), identity),
+		queryFn: async () => unwrapCapxulResult(await scopedClient(client, CAPXUL_OPERATIONS.parties.contacts.list, orgId).addressBook.list({ includeHidden: false })).items,
+		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();
+	const identity = useCapxulIdentityOrNull();
+	return useQuery({
+		queryKey: accountKey(capxulKeys.payrollGroups(orgId), identity),
+		queryFn: async () => unwrapCapxulResult(await scopedClient(client, CAPXUL_OPERATIONS.org.payroll.groups.list, orgId).payroll.groups.list()),
+		enabled: client !== null && orgId !== void 0
+	});
+}
+function usePayrollRuns(orgId) {
+	const client = useCapxulClientOrNull();
+	const identity = useCapxulIdentityOrNull();
+	return useQuery({
+		queryKey: accountKey(capxulKeys.payrollRuns(orgId), identity),
+		queryFn: async () => unwrapCapxulResult(await scopedClient(client, CAPXUL_OPERATIONS.org.payroll.runs, orgId).payroll.runs()),
+		enabled: client !== null && orgId !== void 0
+	});
+}
+/**
+* The active engagement terms of the org's employed people (#1638) — the rows
+* ruling Q3 lets `.Amounts` prefill a rate from.
+*
+* The read is gated on `canSpend` server-side, exactly as the groups read is.
+* A member who may not spend therefore reads an error here and composes with no
+* seed, which is the same composer they had before this read existed.
+*/
+function useOrgTerms(orgId) {
+	const client = useCapxulClientOrNull();
+	const identity = useCapxulIdentityOrNull();
+	return useQuery({
+		queryKey: accountKey(capxulKeys.payrollTerms(orgId), identity),
+		queryFn: async () => unwrapCapxulResult(await scopedClient(client, CAPXUL_OPERATIONS.org.payroll.terms, orgId).payroll.terms()),
+		enabled: client !== null && orgId !== void 0
+	});
+}
+function useOrgTreasury(orgId) {
+	const client = useCapxulClientOrNull();
+	const identity = useCapxulIdentityOrNull();
+	return useQuery({
+		queryKey: accountKey(capxulKeys.orgTreasury(orgId), identity),
+		queryFn: async () => unwrapCapxulResult(await scopedClient(client, CAPXUL_OPERATIONS.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 — Organization AND acting account
+* (#2007 R19) — so a payroll screen inside a `.Can` wrapper still reads
+* `org(id).me()` once, and an account replacement is a miss for both of them
+* rather than the previous person's Budgets for both.
+*/
+function useOrgMe(orgId) {
+	const client = useCapxulClientOrNull();
+	const identity = useCapxulIdentityOrNull();
+	return useQuery({
+		queryKey: capxulKeys.orgMe(orgId, actingAccount(identity)),
+		queryFn: async () => unwrapCapxulResult(await scopedClient(client, CAPXUL_OPERATIONS.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/payroll/use-authorize-run.ts
+/**
+* Authorize one persisted run draft. A draft from a scope the composer has
+* left — another person or organization — is refused, never sent.
+*/
+function useAuthorizeRun(input) {
+	const { client, currentScope, orgId, restoreDraft, setDraft } = input;
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async ({ candidate, options }) => {
+			if (candidate.scope !== currentScope.current) throw Errors.notAuthenticated();
+			return executeRunDraft(candidate, async (persisted, onRequestKey, onResolved) => {
+				if (candidate.scope === currentScope.current) setDraft(persisted);
+				return unwrapCapxulResult(await scopedClient(client, CAPXUL_OPERATIONS.org.payroll.authorizeRun, orgId).payroll.authorizeRun(persisted.input, {
+					...toInvocationControls(options),
+					onResolved,
+					onRequestKey: (key) => {
+						if (candidate.scope !== currentScope.current) throw Errors.notAuthenticated();
+						onRequestKey(key);
+					}
+				}));
+			});
+		},
+		onSettled: (_run, _error, { candidate }) => {
+			queryClient.invalidateQueries({ queryKey: capxulKeys.payrollRuns(orgId) });
+			if (candidate.scope === currentScope.current) restoreDraft(candidate.scope);
+		}
+	});
+}
+//#endregion
+//#region src/payroll/minor-units.ts
+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
+	};
+}
+/** Convert exact raw units to one asset quantity without a fiat denomination. */
+function assetFromMinorUnits(raw, asset) {
+	const money = fromMinorUnits(raw, {
+		currency: toCurrencyCode("USD"),
+		decimals: asset.decimals
+	});
+	return {
+		asset: asset.asset,
+		value: money.value
+	};
+}
+//#endregion
+//#region src/payroll/terms-prefill.ts
+/**
+* Is this period exactly one UTC calendar month, CLOSED at both ends?
+*
+* Closed because that is the convention `periodStart` / `periodEnd` already
+* carry: an instant run stores `periodStart === periodEnd`, one instant rather
+* than a half-open window of zero length. One convention, the shipped one — the
+* first run that actually carries a period will assert it here.
+*
+* A `month` rate states what one month costs and nothing else, so anything that
+* is not exactly a month leaves the rate underivable and seeds nothing. Half a
+* month is not half the rate — that would be proration, a policy no layer of
+* this item owns.
+*/
+function spansOneMonth(period) {
+	const at = new Date(period.start);
+	const first = Date.UTC(at.getUTCFullYear(), at.getUTCMonth(), 1);
+	const next = Date.UTC(at.getUTCFullYear(), at.getUTCMonth() + 1, 1);
+	return period.start === first && period.end === next - 1;
+}
+/** A stored `rate` this module can count. Nothing decodes the row before us. */
+const MINOR_UNITS = /^\d+$/u;
+/**
+* The typed-amount text a rate becomes: a plain decimal, NOT a display string.
+* `null` when the stored rate is not minor units at all.
+*
+* The text is what the employer sees in the amount input and what the run
+* submits, so it must survive a round trip back through `parseMoney`.
+* `formatMoney` appends a currency code, which never would.
+*
+* The shape check is not belt-and-braces. `engagementTerms.rate` is a bare
+* `v.string()`, the SDK maps the row rather than decoding it, and this function
+* runs inside a render — so an unhandled `BigInt("")` would take the whole
+* composer down instead of one seed. `sumTypedAmounts` in this same folder
+* skips what it cannot read for the same reason.
+*/
+function typedAmount(terms) {
+	if (!MINOR_UNITS.test(terms.rate)) return null;
+	const value = fromMinorUnits(BigInt(terms.rate), terms).value;
+	return value.includes(".") ? value.replace(/\.?0+$/u, "") : value;
+}
+/**
+* The seed text per party, for the recipients whose terms row states a rate
+* this run can pay.
+*
+* Three facts stop a seed, and each one stops it SILENTLY: a recipient with no
+* seed gets the empty field they had before this read existed, never an error
+* on a value they did not type.
+*
+*   the unit      `paycheck` always states a rate. `month` states one only over
+*                 a month (ruling Q3). `hour`, `week` and `year` state a rate
+*                 for a period the run does not carry.
+*   the currency  `.Amounts` is denominated in the TREASURY asset's currency and
+*                 the one-option dropdown cannot be changed. A rate in another
+*                 currency is not that money, and converting it would be Capxul
+*                 computing pay.
+*   the text      a rate that is not minor units at all, or that does not parse
+*                 back to positive money — a zero rate, or one counted in finer
+*                 units than the asset — would seed a field that is wrong the
+*                 instant it appears.
+*/
+function termsSeeds(terms, asset, period) {
+	const seeds = /* @__PURE__ */ new Map();
+	if (asset === null) return seeds;
+	for (const row of terms) {
+		if (!(row.unit === "paycheck" || row.unit === "month" && spansOneMonth(period)) || row.currency !== asset.currency) continue;
+		const text = typedAmount(row);
+		if (text === null || isMoneyParseError(parseMoney(text, asset))) continue;
+		seeds.set(row.partyId, text);
+	}
+	return seeds;
+}
+//#endregion
+//#region src/payroll/run-composer.ts
+/**
+* The period this composer composes: an INSTANT run (ruling Q3). `authorizeRun`
+* stamps `start === end === runAt` at submit, and the payslip's period renders
+* that date.
+*
+* WHICH instant it is cannot change a prefill answer, because no single instant
+* spans a calendar month. So the seed asks its question with the SHAPE the run
+* will submit, rather than with a live clock that would rebuild the seed map on
+* every render. A later period-bearing run passes its own window and reaches
+* the `month` branch without a second rule.
+*/
+const INSTANT_RUN_PERIOD = {
+	start: 0,
+	end: 0
+};
+/**
+* The text one `.Amounts` row shows: the employer's own draft, else the terms
+* seed. Read in BOTH places a value is needed — the rendered entries and the
+* parsed totals — so the summary can never state a number the fields do not.
+*/
+function amountText(amounts, seeds, recipientId) {
+	return amounts[recipientId]?.value ?? seeds.get(recipientId) ?? "";
+}
+function freshRunItems(input) {
+	const items = [];
+	for (const [index, recipientId] of input.selected.entries()) {
+		const to = input.payableRefs[index];
+		const amount = input.amounts[index];
+		const terms = input.compensationTerms.get(recipientId);
+		if (to === void 0 || amount === void 0 || terms === void 0) return Errors.wrongState({
+			method: CAPXUL_OPERATIONS.payroll.runs.authorize,
+			currentState: [
+				...to === void 0 ? ["recipient-unpayable"] : [],
+				...amount === void 0 ? ["amount-missing"] : [],
+				...terms === void 0 ? ["terms-missing"] : []
+			].join(","),
+			validStates: ["payable-priced-recipient-under-terms"]
+		});
+		const rawAmount = toRaw(amount, requireAsset(amount.asset)).toString();
+		items.push({
+			to: {
+				kind: "party",
+				partyId: toPartyId(recipientId)
+			},
+			partyId: recipientId,
+			amount,
+			gross: rawAmount,
+			net: rawAmount,
+			adjustments: []
+		});
+	}
+	return items;
+}
+/** The run a fresh composer authorizes: an INSTANT run stamped at submit. */
+function freshRunDraft(input) {
+	const items = freshRunItems(input);
+	if (!Array.isArray(items)) return items;
+	const runAt = Date.now();
+	const metadata = requireAsset(input.assetMoney.asset);
+	return {
+		version: 1,
+		scope: input.scope,
+		asset: {
+			id: input.assetId,
+			currency: metadata.symbol,
+			decimals: metadata.decimals
+		},
+		input: {
+			permissionId: input.permissionId,
+			asset: input.assetId,
+			period: {
+				start: runAt,
+				end: runAt
+			},
+			items
+		}
+	};
+}
+function hasRequiredCompensation(frozen, writerNamesSelectedAsset, selected, terms) {
+	return frozen || !writerNamesSelectedAsset || selected.every((recipientId) => terms.has(recipientId));
+}
+/**
+* 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, scope, frozen) {
+	if (frozen) prefill = void 0;
+	const seeds = Object.entries(initialAmounts(prefill)).map(([recipientId, draft]) => `${recipientId}=${draft.value}`).sort();
+	return [
+		orgId ?? "",
+		...prefill?.recipientIds ?? [],
+		"|",
+		...seeds,
+		scope ?? "pending"
+	].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 remainingBalanceDisplay(available, total, asset) {
+	if (available === null || total === null || asset === null) return null;
+	const remaining = available - total;
+	const magnitude = remaining < 0n ? -remaining : remaining;
+	const formatted = formatAssetAmount(assetFromMinorUnits(magnitude, {
+		asset: asset.asset,
+		decimals: requireAsset(asset.asset).decimals
+	}));
+	return remaining < 0n ? `-${formatted}` : formatted;
+}
+/** Persisted replay keeps its authorized Budget and asset; a prior debit cannot block its own recovery. */
+function runAuthorityFacts(draft, budgets, asset, money, funds) {
+	return {
+		budgetCount: draft !== null && !budgets.some((budget) => budget.id === draft.input.permissionId) ? 0 : budgets.length,
+		hasAsset: asset !== null && (draft === null || draft.asset.id === asset.id && draft.input.asset === money?.asset),
+		funds: draft?.input.requestKey === void 0 ? funds : "available"
+	};
+}
+/**
+* The 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";
+	if (facts.funds === "insufficient") return "insufficient-funds";
+	return facts.writeNamesAsset ? null : "asset-unnamed";
+}
+//#endregion
+//#region src/payroll/use-run-amounts.ts
+/**
+* The run's money: one `.Amounts` entry per selected recipient, in SELECTION
+* order, the parsed total, and whether the treasury position covers it.
+*/
+function useRunAmounts(input) {
+	const { amounts, assetMoney, change, names, selected, terms } = input;
+	const seeds = useMemo(() => {
+		if (assetMoney === null) return /* @__PURE__ */ new Map();
+		const metadata = requireAsset(assetMoney.asset);
+		return termsSeeds(terms ?? [], metadata.peg === null ? null : {
+			currency: metadata.peg,
+			decimals: metadata.decimals
+		}, INSTANT_RUN_PERIOD);
+	}, [assetMoney, terms]);
+	const entries = useMemo(() => {
+		if (assetMoney === null) return [];
+		return selected.map((recipientId) => {
+			const value = amountText(amounts, seeds, recipientId);
+			const parsed = value.trim() === "" ? null : parseAssetAmount(value, requireAsset(assetMoney.asset));
+			return {
+				recipientId,
+				name: names.get(recipientId)?.name ?? recipientId,
+				value,
+				change: (text) => change(recipientId, text),
+				error: parsed !== null && isMoneyParseError(parsed) ? parsed.reason : null,
+				prefilled: amounts[recipientId]?.prefilled ?? seeds.has(recipientId),
+				currency: requireAsset(assetMoney.asset).symbol
+			};
+		});
+	}, [
+		amounts,
+		assetMoney,
+		change,
+		names,
+		seeds,
+		selected
+	]);
+	const parsedAmounts = useMemo(() => {
+		if (assetMoney === null || selected.length === 0) return null;
+		const money = [];
+		for (const recipientId of selected) {
+			const parsed = parseAssetAmount(amountText(amounts, seeds, recipientId), requireAsset(assetMoney.asset));
+			if (isMoneyParseError(parsed)) return null;
+			money.push(parsed);
+		}
+		return money;
+	}, [
+		amounts,
+		assetMoney,
+		seeds,
+		selected
+	]);
+	const total = useMemo(() => parsedAmounts === null || assetMoney === null ? null : {
+		asset: assetMoney.asset,
+		value: assetFromMinorUnits(parsedAmounts.reduce((sum, amount) => sum + toRaw(amount, requireAsset(amount.asset)), 0n), {
+			asset: assetMoney.asset,
+			decimals: requireAsset(assetMoney.asset).decimals
+		}).value
+	}, [assetMoney, parsedAmounts]);
+	const availableRaw = assetMoney === null ? null : toRaw(assetMoney, requireAsset(assetMoney.asset));
+	const totalRaw = total === null ? null : toRaw(total, requireAsset(total.asset));
+	return {
+		entries,
+		parsedAmounts,
+		total,
+		availableRaw,
+		totalRaw,
+		funds: availableRaw === null || totalRaw === null ? "unknown" : totalRaw > availableRaw ? "insufficient" : "available"
+	};
+}
+//#endregion
+//#region src/payroll/use-run-asset.ts
+/**
+* `.Asset` — names a token from the treasury Account's `balances`, never its
+* `available`, which is the Account's fiat VALUATION of its pegged positions
+* (ADR-0028 R5/R6). The option is keyed on the ASSET id: several positions
+* share one account id, and a symbol is display only (ADR-0028 R3). The run
+* writer receives the selected asset explicitly.
+*/
+function useRunAsset(account, canSelect) {
+	const assetSelections = useMemo(() => assetSelectionsFromAccount(account), [account]);
+	const assetOptions = useMemo(() => assetSelections.map((selection) => selection.option), [assetSelections]);
+	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;
+	return {
+		assetOptions,
+		selectedAsset,
+		selectAsset: useCallback((id) => {
+			if (canSelect()) setSelectedAssetId((current) => assetOptions.some((option) => option.id === id) ? id : current);
+		}, [assetOptions, canSelect]),
+		assetMoney: assetSelections.find((selection) => selection.option.id === selectedAsset?.id)?.money ?? null
+	};
+}
+//#endregion
+//#region src/payroll/use-run-recipients.ts
+/**
+* Who the run pays: each selected recipient's name, the payable `Ref` the
+* org's own address book handed back, and the paycheck terms it runs under.
+*/
+function useRunRecipients(input) {
+	const { options, refs, selected, terms } = input;
+	return {
+		named: useMemo(() => new Map(options.map((option) => [option.id, option])), [options]),
+		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]),
+		compensationTerms: useMemo(() => new Map((terms ?? []).filter((row) => row.unit === "paycheck" && /^[1-9][0-9]*$/u.test(row.rate)).map((row) => [row.partyId, row])), [terms])
+	};
+}
+//#endregion
+//#region src/payroll/use-payroll-run.ts
+function usePayrollRun(input) {
+	const { orgId, prefill, onRun, onFailed } = input;
+	const client = useCapxulClientOrNull();
+	const submitGate = useRef(false);
+	const signerStatus = useSignerStatus(client);
+	const roster = useOrgRoster(orgId);
+	const groups = usePayrollGroups(orgId);
+	const treasury = useOrgTreasury(orgId);
+	const me = useOrgMe(orgId);
+	const terms = useOrgTerms(orgId);
+	const [selected, setSelected] = useState(() => prefill?.recipientIds ?? []);
+	const [amounts, setAmounts] = useState(() => initialAmounts(prefill));
+	const { draftScope, currentScope, draft, draftError, restorationPending, activateDraft, restoreDraft, setDraft, recovery, draftBlocked } = useRunDraft(client, orgId, useCallback((restored) => {
+		setSelected(restored.input.items.map((item) => item.partyId));
+		if (requireAsset(restored.input.asset).assetId === restored.input.asset) setAmounts(Object.fromEntries(restored.input.items.map((item) => [item.partyId, {
+			value: item.amount.value,
+			prefilled: false
+		}])));
+	}, []));
+	const frozen = draft !== null;
+	const composerKey = composerIdentity(orgId, prefill, draftScope, frozen);
+	const [seededKey, setSeededKey] = useState(composerKey);
+	if (seededKey !== composerKey) {
+		setSeededKey(composerKey);
+		if (!frozen) {
+			setSelected(prefill?.recipientIds ?? []);
+			setAmounts(initialAmounts(prefill));
+		}
+	}
+	const toggle = useCallback((id) => {
+		if (submitGate.current || frozen || restorationPending || draftError !== null) return;
+		setSelected((current) => current.includes(id) ? current.filter((held) => held !== id) : [...current, id]);
+	}, [
+		frozen,
+		restorationPending,
+		draftError
+	]);
+	const remove = useCallback((id) => {
+		if (!submitGate.current && !frozen && !restorationPending && draftError === null) setSelected((current) => current.filter((held) => held !== id));
+	}, [
+		frozen,
+		restorationPending,
+		draftError
+	]);
+	const change = useCallback((id, text) => {
+		if (!submitGate.current && !frozen && !restorationPending && draftError === null) setAmounts((current) => ({
+			...current,
+			[id]: {
+				value: text,
+				prefilled: false
+			}
+		}));
+	}, [
+		frozen,
+		restorationPending,
+		draftError
+	]);
+	const canSelectAsset = useCallback(() => !submitGate.current && !frozen, [frozen]);
+	const { assetOptions, selectedAsset, selectAsset, assetMoney } = useRunAsset(treasury.data ?? null, canSelectAsset);
+	const { named, payableRefs, compensationTerms } = useRunRecipients({
+		options: roster.options,
+		refs: roster.refs,
+		selected,
+		terms: terms.data?.items
+	});
+	const { entries, parsedAmounts, total, availableRaw, totalRaw, funds } = useRunAmounts({
+		assetMoney,
+		terms: terms.data?.items,
+		amounts,
+		selected,
+		names: named,
+		change
+	});
+	const budgets = me.data?.budgets ?? [];
+	const writerNamesSelectedAsset = writeNamesAsset();
+	const blockedReason = firstFalseFact({
+		signerReady: signerStatus === "ready",
+		...runAuthorityFacts(draft, budgets, selectedAsset, assetMoney, funds),
+		recipientCount: payableRefs === null ? 0 : selected.length,
+		amountsParse: total !== null && hasRequiredCompensation(frozen, writerNamesSelectedAsset, selected, compensationTerms),
+		writeNamesAsset: writerNamesSelectedAsset
+	});
+	const authorize = useAuthorizeRun({
+		client,
+		orgId,
+		currentScope,
+		setDraft,
+		restoreDraft
+	});
+	const totalDisplay = total === null ? null : formatAssetAmount(total);
+	const authorizeMutate = authorize.mutate;
+	const submit = useCallback((options) => {
+		const attempt = toInvocationOptions(options);
+		const permissionId = budgets[0]?.id;
+		if (blockedReason !== null || submitGate.current || draftBlocked || draftScope === null || assetMoney === null || selectedAsset === null) return;
+		if (permissionId === void 0 || totalDisplay === null || parsedAmounts === null) return;
+		if (payableRefs === null) return;
+		const recipientCount = selected.length;
+		const candidate = frozen ? draft : freshRunDraft({
+			scope: draftScope,
+			assetId: selectedAsset.id,
+			assetMoney,
+			permissionId,
+			selected,
+			payableRefs,
+			amounts: parsedAmounts,
+			compensationTerms
+		});
+		if (isCapxulError(candidate)) {
+			onFailed(candidate);
+			return;
+		}
+		submitGate.current = true;
+		authorizeMutate({
+			candidate,
+			...attempt === void 0 ? {} : { options: attempt }
+		}, {
+			onSuccess: (run) => {
+				if (candidate.scope === currentScope.current) onRun({
+					id: run.id,
+					totalDisplay,
+					recipientCount
+				});
+			},
+			onError: (error) => {
+				if (candidate.scope === currentScope.current) onFailed(error);
+			},
+			onSettled: () => {
+				submitGate.current = false;
+			}
+		});
+	}, [
+		authorizeMutate,
+		draft,
+		frozen,
+		draftScope,
+		restorationPending,
+		draftError,
+		draftBlocked,
+		assetMoney,
+		selectedAsset,
+		blockedReason,
+		budgets,
+		compensationTerms,
+		onFailed,
+		onRun,
+		parsedAmounts,
+		payableRefs,
+		selected,
+		totalDisplay
+	]);
+	return {
+		activateDraft,
+		recipients: {
+			options: roster.options,
+			groups: (groups.data?.items ?? []).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",
+			isPending: orgId !== void 0 && treasury.isPending
+		},
+		summary: {
+			recipientCount: selected.length,
+			totalDisplay,
+			balanceAfterDisplay: remainingBalanceDisplay(availableRaw, totalRaw, assetMoney),
+			funds
+		},
+		actions: {
+			submit,
+			isSubmitting: authorize.isPending,
+			blocked: blockedReason !== null || draftBlocked,
+			blockedReason,
+			recovery,
+			recoveryError: draftError
+		}
+	};
+}
+//#endregion
+//#region src/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$1({ 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$1({ children }) {
+	return /* @__PURE__ */ jsx(Fragment, { children: children(usePayrollRunContext().summary) });
+}
+function Actions({ children }) {
+	const engine = usePayrollRunContext();
+	useEffect(engine.activateDraft, [engine.activateDraft]);
+	return /* @__PURE__ */ jsx(Fragment, { children: children(engine.actions) });
+}
+/** The compound shape the app's own design system already uses (`StatusTabs`). */
+const CapxulPayrollRun = Object.assign(Root$1, {
+	Recipients,
+	Amounts,
+	Asset,
+	Summary: Summary$1,
+	Actions
+});
+//#endregion
+//#region src/payroll/use-payroll.ts
+/** Money reads the same way everywhere on this screen: amount then code. */
+const GRAMMAR = { grammar: "code" };
+/**
+* One captured snapshot, or nothing — never a fabricated empty options object,
+* and never a DOM event a screen wired straight to `onClick`.
+*/
+function carry(options) {
+	const attempt = toInvocationOptions(options);
+	return attempt === void 0 ? {} : { options: attempt };
+}
+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),
+		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 invalidate = useCallback(() => queryClient.invalidateQueries({ queryKey: capxulKeys.payrollGroups(orgId) }), [orgId, queryClient]);
+	const saving = useMutation({
+		mutationFn: async ({ input, options }) => unwrapCapxulResult(await scopedClient(client, CAPXUL_OPERATIONS.org.payroll.groups.save, orgId).payroll.groups.save(input, toInvocationControls(options))),
+		onSettled: invalidate
+	});
+	const removing = useMutation({
+		mutationFn: async ({ id, options }) => unwrapCapxulResult(await scopedClient(client, CAPXUL_OPERATIONS.org.payroll.groups.remove, orgId).payroll.groups.remove(id, toInvocationControls(options))),
+		onSettled: invalidate
+	});
+	const saveAsync = saving.mutateAsync;
+	const removeAsync = removing.mutateAsync;
+	const save = useCallback(async (input, options) => {
+		const refusal = invalidGroup(input);
+		if (refusal !== null) return {
+			ok: false,
+			error: refusal
+		};
+		try {
+			return {
+				ok: true,
+				value: toPayrollGroupRow(await saveAsync({
+					input,
+					...carry(options)
+				}))
+			};
+		} catch (cause) {
+			return {
+				ok: false,
+				error: toCapxulError(cause)
+			};
+		}
+	}, [saveAsync]);
+	const remove = useCallback(async (id, options) => {
+		try {
+			await removeAsync({
+				id,
+				...carry(options)
+			});
+			return {
+				ok: true,
+				value: void 0
+			};
+		} catch (cause) {
+			return {
+				ok: false,
+				error: toCapxulError(cause)
+			};
+		}
+	}, [removeAsync]);
+	const rows = useMemo(() => (groups.data?.items ?? []).map(toPayrollGroupRow), [groups.data]);
+	const started = orgId !== void 0;
+	return {
+		summary: {
+			walletBalanceDisplay: treasury.data?.available === void 0 || treasury.data.available === null ? null : formatMoney(treasury.data.available, GRAMMAR),
+			paidThisMonthDisplay: runs.data === void 0 ? null : runs.data.settledThisMonth.map(formatAssetAmount).join(", "),
+			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: saving.isPending || removing.isPending,
+			isLoading: started && groups.data === void 0 && groups.error === null,
+			error: groups.error
+		}
+	};
+}
+//#endregion
+//#region src/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({ orgId, children }) {
+	const engine = usePayroll(orgId);
+	return /* @__PURE__ */ jsx(PayrollContext.Provider, {
+		value: engine,
+		children
+	});
+}
+function Summary({ 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, {
+	Summary,
+	Groups
+});
+//#endregion
+export { CapxulActivity, CapxulAuthenticationController, CapxulClientConnection, 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, useCapxulClientOrNull, useCapxulCreateOrg, useCapxulDestination, useCapxulHandleAvailability, useCapxulHoldings, useCapxulIdentity, useCapxulImageUpload, useCapxulOrgMembers, useCapxulOrgRoles, useCapxulOrgTreasury, useCapxulOrganizationPay, useCapxulOrganizationPayBatch, useCapxulOrgs, useCapxulPay, useCapxulPayment, useCapxulPayments, useCapxulPermission, useCapxulPermissionAssign, useCapxulPermissionChange, useCapxulPermissionCreate, useCapxulPermissionReplace, useCapxulPermissionRevoke, useCapxulPermissions, useCapxulProfile, useCapxulSend, useCapxulTransitions, useCapxulUploadImage };