@capxul/sdk-react 2.1.1 → 2.3.0

package/dist/index.mjs

@@ -1,166 +1,9 @@
 "use client";
-import { a as useCapxulAuth, c as useCapxulIdentityOrNull, d as capxulKeys, f as useCapxulClientOrNull, i as entered, l as useCapxulSend, n as CapxulOnboardingController, o as useCapxulDestination, p as useCapxul, r as CapxulProvider, s as useCapxulIdentity, t as CapxulAuthenticationController, u as useCapxulTransitions } from "./controllers-Chqyy3HR.mjs";
-import { useEffect, useState } from "react";
+import { a as useCapxulAuth, c as useCapxulIdentityOrNull, d as capxulKeys, f as useCapxulClientOrNull, i as entered, l as useCapxulSend, n as CapxulOnboardingController, o as useCapxulDestination, p as useCapxul, r as CapxulProvider, s as useCapxulIdentity, t as CapxulAuthenticationController, u as useCapxulTransitions } from "./controllers-VwUPB619.mjs";
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
-import { fingerprintPaymentIntent } from "@capxul/sdk";
-//#region ../errors/src/errors.ts
-const CAPXUL_ERROR_CODES = [
-	"NOT_AUTHENTICATED",
-	"EMAIL_DELIVERY_FAILED",
-	"PROFILE_NOT_FOUND",
-	"SMART_ACCOUNT_MISSING",
-	"PLAYER_NOT_FOUND",
-	"ACCOUNT_NOT_FOUND",
-	"PROVIDER_ERROR",
-	"CAPABILITY_UNAVAILABLE",
-	"INVALID_INPUT",
-	"ENV_MISSING",
-	"NOT_IMPLEMENTED",
-	"VERIFICATION_REQUIRED",
-	"INSUFFICIENT_BALANCE",
-	"INVALID_RECIPIENT",
-	"ROLE_PERMISSION_DENIED",
-	"TRANSACTION_FAILED",
-	"RATE_LIMITED",
-	"NETWORK_ERROR",
-	"UNKNOWN",
-	"OTP_EXPIRED",
-	"SIGNER_REJECTED",
-	"CANCELLED",
-	"WRONG_STATE",
-	"STALE_EPOCH",
-	"SUPERSEDED",
-	"WORK_DIED",
-	"ACTOR_STOPPED"
-];
-var CapxulError$1 = class extends Error {
-	code;
-	details;
-	correlationId;
-	layer;
-	constructor(code, message, options = {}) {
-		super(message, "cause" in options ? { cause: options.cause } : void 0);
-		this.name = "CapxulError";
-		this.code = code;
-		if (options.details !== void 0) this.details = options.details;
-		if (options.correlationId !== void 0) this.correlationId = options.correlationId;
-		if (options.layer !== void 0) this.layer = options.layer;
-	}
-};
-const Errors = {
-	notAuthenticated: (message, opts) => new CapxulError$1("NOT_AUTHENTICATED", message ?? "Not authenticated", opts?.failure_mode ? { details: { failure_mode: opts.failure_mode } } : void 0),
-	emailDeliveryFailed: (detail) => new CapxulError$1("EMAIL_DELIVERY_FAILED", "Failed to send email", { details: { detail } }),
-	profileNotFound: (authUserId) => new CapxulError$1("PROFILE_NOT_FOUND", `Profile not found for user ${authUserId}`, { details: { authUserId } }),
-	smartAccountMissing: (authUserId) => new CapxulError$1("SMART_ACCOUNT_MISSING", "Smart account not provisioned", { details: { authUserId } }),
-	playerNotFound: (playerId) => new CapxulError$1("PLAYER_NOT_FOUND", playerId ? `Openfort player ${playerId} not found` : "Openfort player not found", playerId === void 0 ? void 0 : { details: { playerId } }),
-	accountNotFound: (accountId) => new CapxulError$1("ACCOUNT_NOT_FOUND", accountId ? `Openfort account ${accountId} not found` : "Openfort account not found", accountId === void 0 ? void 0 : { details: { accountId } }),
-	providerError: (provider, operation, cause, opts) => {
-		const details = {
-			provider,
-			operation
-		};
-		if (opts?.failure_mode) details.failure_mode = opts.failure_mode;
-		return new CapxulError$1("PROVIDER_ERROR", `Provider error: ${provider} ${operation}`, {
-			cause,
-			details
-		});
-	},
-	capabilityUnavailable: (provider, operation) => new CapxulError$1("CAPABILITY_UNAVAILABLE", "Provider capability is unavailable", { details: {
-		provider,
-		operation
-	} }),
-	invalidInput: (field, reason) => new CapxulError$1("INVALID_INPUT", `Invalid ${field}: ${reason}`, { details: {
-		field,
-		reason
-	} }),
-	envMissing: (name) => new CapxulError$1("ENV_MISSING", `Environment variable ${name} not configured`, { details: { name } }),
-	notImplemented: (domain, method) => new CapxulError$1("NOT_IMPLEMENTED", `${domain}.${method} is not yet implemented. This feature is planned for a future release.`, { details: {
-		domain,
-		method
-	} }),
-	/**
-	* Sibling factory to {@link Errors.providerError} for the per-state timeout
-	* path in flows. Same `PROVIDER_ERROR` code as
-	* `providerError`, plus a `details.reason: "timeout"` discriminator so
-	* downstream observers can distinguish failure modes without parsing the
-	* message string. The redacted message names the timeout budget; the
-	* native `cause` carries the same information for `reportError` fidelity.
-	*/
-	providerTimeout: (provider, operation, timeoutMs) => new CapxulError$1("PROVIDER_ERROR", `Provider error: ${provider} ${operation} (timeout exceeded ${timeoutMs}ms)`, {
-		details: {
-			provider,
-			operation,
-			reason: "timeout"
-		},
-		cause: /* @__PURE__ */ new Error(`timeout: ${operation} exceeded ${timeoutMs}ms`)
-	}),
-	verificationRequired: (details) => {
-		return new CapxulError$1("VERIFICATION_REQUIRED", "rail" in details ? `Verification is required before ${details.rail} can use ${details.currentKind}.` : `Verification tier ${details.requiredTier} is required.`, { details });
-	},
-	insufficientBalance: (asset, available, required) => new CapxulError$1("INSUFFICIENT_BALANCE", `Insufficient ${asset} balance`, { details: {
-		asset,
-		available,
-		required
-	} }),
-	invalidRecipient: (reason) => new CapxulError$1("INVALID_RECIPIENT", `Invalid recipient: ${reason}`, { details: { reason } }),
-	/**
-	* The org Zodiac Roles modifier REFUSED the spend on-chain (G4 · #547): the
-	* member's role condition (per-tx cap, per-day allowance, allowed recipient,
-	* or membership) was violated, so `execTransactionWithRole` reverted. This is
-	* a PERMISSION denial — explicitly NOT an `INSUFFICIENT_BALANCE` (the treasury
-	* held the funds; the role's authority is what bound). `reason` discriminates
-	* the violated condition (`over_cap` / `daily_cap` / `not_member` /
-	* `disallowed_recipient` / `condition_violation`); leak-safe — no on-chain
-	* identifiers ever enter the details.
-	*/
-	rolePermissionDenied: (details) => new CapxulError$1("ROLE_PERMISSION_DENIED", `Org role denied this spend on-chain (${details.reason}).`, { details: details.operation === void 0 ? { reason: details.reason } : {
-		reason: details.reason,
-		operation: details.operation
-	} }),
-	/**
-	* A transaction (or sponsored UserOp) failed. `details.reason` discriminates
-	* the failure mode for callers that must distinguish a CONFIRMED on-chain
-	* revert (`"onchain_revert"` — the op executed and reverted, e.g. a Zodiac
-	* Roles condition violation) from an inconclusive infra failure. A confirmed
-	* revert is the ONLY mode the org spend port may map to a roles denial.
-	*/
-	transactionFailed: (operation, cause, extra) => new CapxulError$1("TRANSACTION_FAILED", `Transaction failed: ${operation}`, {
-		cause,
-		details: extra?.reason === void 0 ? { operation } : {
-			operation,
-			reason: extra.reason
-		}
-	}),
-	rateLimited: (details) => new CapxulError$1("RATE_LIMITED", "Rate limit exceeded", details === void 0 ? void 0 : { details: { ...details } }),
-	networkError: (operation, cause) => new CapxulError$1("NETWORK_ERROR", `Network error during ${operation}`, {
-		cause,
-		details: { operation }
-	}),
-	unknown: (cause) => new CapxulError$1("UNKNOWN", "Unknown error", { cause }),
-	otpExpired: (details) => new CapxulError$1("OTP_EXPIRED", "Verification code has expired. Request a new one.", details === void 0 ? void 0 : { details: { ...details } }),
-	signerRejected: (details) => new CapxulError$1("SIGNER_REJECTED", "Signer rejected the request.", {
-		cause: details.cause,
-		details: details.reason === void 0 ? { source: details.source } : {
-			source: details.source,
-			reason: details.reason
-		}
-	}),
-	cancelled: (details) => new CapxulError$1("CANCELLED", "Operation was cancelled.", details === void 0 ? void 0 : { details: { ...details } }),
-	/**
-	* Method called from a flow state where its precondition fails (TA16). The
-	* SDK's method API short-circuits with this error before driving the
-	* internal state machine. `currentState` is the Effect-machine snapshot
-	* tag (stringified from the SDK's actor-shell snapshot; see
-	* `packages/errors/CONTEXT.md`); `validStates`
-	* enumerates the states the method accepts.
-	*/
-	wrongState: (details) => new CapxulError$1("WRONG_STATE", `${details.method} called from state '${details.currentState}'; valid states: ${details.validStates.join(", ")}`, { details: {
-		...details,
-		validStates: [...details.validStates]
-	} })
-};
-new Set(CAPXUL_ERROR_CODES);
-//#endregion
+import { CapxulError, Errors, fingerprintPaymentIntent, formatMoney, isClaimed, isClaimed as isClaimed$1, isMoneyParseError, isRestoring, isRestoring as isRestoring$1, parseMoney, resolveIdentityDestination } from "@capxul/sdk";
+import { Fragment, jsx } from "react/jsx-runtime";
 //#region src/internal/require-bootstrapped-client.ts
 /**
 * Narrow the bootstrap-nullable client to a ready client inside a query /
@@ -182,12 +25,10 @@ function requireBootstrappedClient(client, method) {
 * 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. The legacy
-* telemetry/operation arguments remain temporarily source-compatible with the
-* existing hook call sites, but are deliberately ignored so React cannot
+* Failure observation belongs to the core SDK method boundary. React does not
 * report the same logical failure a second time.
 */
-function unwrapCapxulResult(result, _legacyTelemetry, _legacyOperation = "query") {
+function unwrapCapxulResult(result) {
 	if (result.ok) return result.value;
 	throw result.error;
 }
@@ -198,7 +39,7 @@ function useCapxulProfile() {
 	const identity = useCapxulIdentityOrNull();
 	return useQuery({
 		queryKey: capxulKeys.profile,
-		queryFn: async () => unwrapCapxulResult(await requireBootstrappedClient(client, "identity.loadCurrent").identity.loadCurrent(), client._internal.telemetry),
+		queryFn: async () => unwrapCapxulResult(await requireBootstrappedClient(client, "identity.loadCurrent").identity.loadCurrent()),
 		enabled: client !== null && identity?.phase === "authenticated"
 	});
 }
@@ -209,8 +50,7 @@ function useCapxulAccountBalance(options) {
 	return useQuery({
 		queryKey: capxulKeys.accountBalance,
 		queryFn: async () => {
-			const bootstrappedClient = requireBootstrappedClient(client, "accounts.read");
-			return unwrapCapxulResult(await bootstrappedClient.accounts.read(), bootstrappedClient._internal.telemetry);
+			return unwrapCapxulResult(await requireBootstrappedClient(client, "accounts.read").accounts.read());
 		},
 		enabled: client !== null && (options?.enabled ?? true)
 	});
@@ -222,8 +62,7 @@ function useCapxulAccountFund() {
 	const queryClient = useQueryClient();
 	return useMutation({
 		mutationFn: async (amount) => {
-			const bootstrappedClient = requireBootstrappedClient(client, "_internal.accounts.fund");
-			return unwrapCapxulResult(await bootstrappedClient._internal.accounts.fund(amount), bootstrappedClient._internal.telemetry, "mutation");
+			return unwrapCapxulResult(await requireBootstrappedClient(client, "_internal.accounts.fund")._internal.accounts.fund(amount));
 		},
 		onSuccess: async () => {
 			await queryClient.invalidateQueries({ queryKey: capxulKeys.accountBalance });
@@ -255,7 +94,7 @@ async function storageKey(operation, intent) {
 }
 function paymentLockManager() {
 	const manager = navigator.locks;
-	if (manager === void 0 || typeof manager.query !== "function") throw new Error("Web Locks are required for payment request keys");
+	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 attemptLockName(storageSlot, attemptId) {
@@ -299,14 +138,14 @@ function readState(key) {
 	const stored = localStorage.getItem(key);
 	if (stored === null) return null;
 	const state = JSON.parse(stored);
-	if (typeof state.key !== "string" || !Array.isArray(state.active) || state.active.some((attempt) => typeof attempt !== "string") || typeof state.resolved !== "boolean") throw new TypeError("Invalid payment request key state");
+	if (typeof state.key !== "string" || !Array.isArray(state.active) || state.active.some((attempt) => typeof attempt !== "string") || typeof state.resolved !== "boolean") throw Errors.providerError("sdk-react", "paymentRequestKey", /* @__PURE__ */ new TypeError("Invalid payment request key state"));
 	return state;
 }
 async function beginPaymentRequestKey(operation, intent) {
-	const storageSlot = await storageKey(operation, intent);
 	let releaseAttemptLock;
 	let forgetPagehideRelease;
 	try {
+		const storageSlot = await storageKey(operation, intent);
 		const attemptId = `attempt_${crypto.randomUUID()}`;
 		releaseAttemptLock = await holdAttemptLock(attemptLockName(storageSlot, attemptId));
 		forgetPagehideRelease = releaseAttemptOnPagehide(releaseAttemptLock);
@@ -408,7 +247,7 @@ function useCapxulPay() {
 			}, async (requestKey) => unwrapCapxulResult(await bootstrappedClient.payments.pay({
 				...input,
 				requestKey
-			}), bootstrappedClient._internal.telemetry, "mutation"));
+			})));
 		},
 		onSuccess: async (payment) => {
 			await invalidateMoneyState(queryClient, {
@@ -423,8 +262,7 @@ function useCapxulCreateCommitment() {
 	const queryClient = useQueryClient();
 	return useMutation({
 		mutationFn: async (input) => {
-			const bootstrapped = requireBootstrappedClient(client, "payments.createCommitment");
-			return unwrapCapxulResult(await bootstrapped.payments.createCommitment(input), bootstrapped._internal.telemetry, "mutation");
+			return unwrapCapxulResult(await requireBootstrappedClient(client, "payments.createCommitment").payments.createCommitment(input));
 		},
 		onSuccess: (payment) => invalidateMoneyState(queryClient, {
 			actor: { kind: "personal" },
@@ -437,8 +275,7 @@ function usePaymentIdMutation(method) {
 	const queryClient = useQueryClient();
 	return useMutation({
 		mutationFn: async (paymentId) => {
-			const bootstrapped = requireBootstrappedClient(client, `payments.${method}`);
-			return unwrapCapxulResult(await bootstrapped.payments[method](paymentId), bootstrapped._internal.telemetry, "mutation");
+			return unwrapCapxulResult(await requireBootstrappedClient(client, `payments.${method}`).payments[method](paymentId));
 		},
 		onSuccess: (payment) => invalidateMoneyState(queryClient, {
 			actor: { kind: "personal" },
@@ -453,8 +290,7 @@ function useCapxulRedirectPayment() {
 	const queryClient = useQueryClient();
 	return useMutation({
 		mutationFn: async (input) => {
-			const bootstrapped = requireBootstrappedClient(client, "payments.redirect");
-			return unwrapCapxulResult(await bootstrapped.payments.redirect(input), bootstrapped._internal.telemetry, "mutation");
+			return unwrapCapxulResult(await requireBootstrappedClient(client, "payments.redirect").payments.redirect(input));
 		},
 		onSuccess: (payment) => invalidateMoneyState(queryClient, {
 			actor: { kind: "personal" },
@@ -468,10 +304,9 @@ function useCapxulPayments(options) {
 	return useQuery({
 		queryKey: capxulKeys.payments,
 		queryFn: async () => {
-			const bootstrappedClient = requireBootstrappedClient(client, "payments.list");
-			return unwrapCapxulResult(await bootstrappedClient.payments.list(), bootstrappedClient._internal.telemetry);
+			return unwrapCapxulResult(await requireBootstrappedClient(client, "payments.list").payments.list());
 		},
-		enabled: client !== null && identity?.phase === "authenticated" && identity.account.at === "claimed" && (options?.enabled ?? true)
+		enabled: client !== null && identity !== null && isClaimed$1(identity) && (options?.enabled ?? true)
 	});
 }
 function useCapxulPayment(paymentId, options) {
@@ -480,8 +315,7 @@ function useCapxulPayment(paymentId, options) {
 		queryKey: capxulKeys.payment(paymentId),
 		queryFn: async () => {
 			if (paymentId === void 0) throw Errors.invalidInput("paymentId", "required for payments.get");
-			const bootstrappedClient = requireBootstrappedClient(client, "payments.get");
-			return unwrapCapxulResult(await bootstrappedClient.payments.get(paymentId), bootstrappedClient._internal.telemetry);
+			return unwrapCapxulResult(await requireBootstrappedClient(client, "payments.get").payments.get(paymentId));
 		},
 		enabled: client !== null && paymentId !== void 0 && (options?.enabled ?? true)
 	});
@@ -502,7 +336,7 @@ function useCapxulOrganizationPay(orgId) {
 			}, async (requestKey) => unwrapCapxulResult(await bootstrapped.org(orgId).payments.pay({
 				...input,
 				requestKey
-			}), bootstrapped._internal.telemetry, "mutation"));
+			})));
 		},
 		onSuccess: async (payment) => {
 			return invalidateMoneyState(queryClient, {
@@ -529,7 +363,7 @@ function useCapxulOrganizationPayBatch(orgId) {
 			}, async (requestKey) => unwrapCapxulResult(await bootstrapped.org(orgId).payments.payBatch({
 				...input,
 				requestKey
-			}), bootstrapped._internal.telemetry, "mutation"));
+			})));
 		},
 		onSuccess: async (payments) => {
 			return Promise.all(payments.map((payment) => invalidateMoneyState(queryClient, {
@@ -549,9 +383,8 @@ function usePermissionMutation(orgId, operation) {
 	const queryClient = useQueryClient();
 	return useMutation({
 		mutationFn: async (input) => {
-			const bootstrapped = requireBootstrappedClient(client, `permissions.${operation}`);
-			const method = bootstrapped.org(orgId).permissions[operation];
-			return unwrapCapxulResult(await method(input), bootstrapped._internal.telemetry, "mutation");
+			const method = requireBootstrappedClient(client, `permissions.${operation}`).org(orgId).permissions[operation];
+			return unwrapCapxulResult(await method(input));
 		},
 		onSuccess: () => queryClient.invalidateQueries({ queryKey: capxulKeys.orgPermissions(orgId) })
 	});
@@ -563,13 +396,13 @@ const useCapxulPermissionRevoke = (orgId) => usePermissionMutation(orgId, "revok
 const useCapxulPermissionReplace = (orgId) => usePermissionMutation(orgId, "replace");
 function useCapxulPermissions(orgId, options) {
 	const client = useCapxulClientOrNull();
+	const identity = useCapxulIdentityOrNull();
 	return useQuery({
 		queryKey: capxulKeys.orgPermissions(orgId),
 		queryFn: async () => {
-			const bootstrapped = requireBootstrappedClient(client, "permissions.list");
-			return unwrapCapxulResult(await bootstrapped.org(orgId).permissions.list(), bootstrapped._internal.telemetry);
+			return unwrapCapxulResult(await requireBootstrappedClient(client, "permissions.list").org(orgId).permissions.list());
 		},
-		enabled: client !== null && (options?.enabled ?? true)
+		enabled: client !== null && identity !== null && isClaimed$1(identity) && (options?.enabled ?? true)
 	});
 }
 function useCapxulPermission(orgId, permissionId) {
@@ -577,9 +410,8 @@ function useCapxulPermission(orgId, permissionId) {
 	return useQuery({
 		queryKey: [...capxulKeys.orgPermissions(orgId), permissionId ?? "pending"],
 		queryFn: async () => {
-			if (permissionId === void 0) throw new Error("permissionId is required");
-			const bootstrapped = requireBootstrappedClient(client, "permissions.get");
-			return unwrapCapxulResult(await bootstrapped.org(orgId).permissions.get(permissionId), bootstrapped._internal.telemetry);
+			if (permissionId === void 0) throw Errors.invalidInput("permissionId", "required for permissions.get");
+			return unwrapCapxulResult(await requireBootstrappedClient(client, "permissions.get").org(orgId).permissions.get(permissionId));
 		},
 		enabled: client !== null && permissionId !== void 0
 	});
@@ -592,10 +424,9 @@ function useCapxulActivity(params) {
 	return useQuery({
 		queryKey: [...capxulKeys.activity, params ?? {}],
 		queryFn: async () => {
-			const bootstrapped = requireBootstrappedClient(client, "activity.list");
-			return unwrapCapxulResult(await bootstrapped.activity.list(params), bootstrapped._internal.telemetry);
+			return unwrapCapxulResult(await requireBootstrappedClient(client, "activity.list").activity.list(params));
 		},
-		enabled: client !== null && identity?.phase === "authenticated" && identity.account.at === "claimed"
+		enabled: client !== null && identity !== null && isClaimed$1(identity)
 	});
 }
 function useCapxulActivityDetail(reference) {
@@ -604,11 +435,10 @@ function useCapxulActivityDetail(reference) {
 	return useQuery({
 		queryKey: capxulKeys.activityDetail(reference),
 		queryFn: async () => {
-			if (reference === void 0) throw new Error("activity reference is required");
-			const bootstrapped = requireBootstrappedClient(client, "activity.get");
-			return unwrapCapxulResult(await bootstrapped.activity.get(reference), bootstrapped._internal.telemetry);
+			if (reference === void 0) throw Errors.invalidInput("reference", "required for activity.get");
+			return unwrapCapxulResult(await requireBootstrappedClient(client, "activity.get").activity.get(reference));
 		},
-		enabled: client !== null && reference !== void 0 && identity?.phase === "authenticated" && identity.account.at === "claimed"
+		enabled: client !== null && reference !== void 0 && identity !== null && isClaimed$1(identity)
 	});
 }
 function useCapxulAnnotateMovement() {
@@ -616,8 +446,7 @@ function useCapxulAnnotateMovement() {
 	const queryClient = useQueryClient();
 	return useMutation({
 		mutationFn: async (input) => {
-			const bootstrapped = requireBootstrappedClient(client, "activity.annotate");
-			return unwrapCapxulResult(await bootstrapped.activity.annotate(input), bootstrapped._internal.telemetry, "mutation");
+			return unwrapCapxulResult(await requireBootstrappedClient(client, "activity.annotate").activity.annotate(input));
 		},
 		onSuccess: () => queryClient.invalidateQueries({ queryKey: capxulKeys.activity })
 	});
@@ -630,10 +459,9 @@ function useCapxulHoldings() {
 	return useQuery({
 		queryKey: capxulKeys.holdings,
 		queryFn: async () => {
-			const bootstrapped = requireBootstrappedClient(client, "holdings.current");
-			return unwrapCapxulResult(await bootstrapped.holdings.current(), bootstrapped._internal.telemetry);
+			return unwrapCapxulResult(await requireBootstrappedClient(client, "holdings.current").holdings.current());
 		},
-		enabled: client !== null && identity?.phase === "authenticated" && identity.account.at === "claimed"
+		enabled: client !== null && identity !== null && isClaimed$1(identity)
 	});
 }
 //#endregion
@@ -643,8 +471,7 @@ function useCapxulOrgs(options) {
 	return useQuery({
 		queryKey: capxulKeys.orgs,
 		queryFn: async () => {
-			const bootstrappedClient = requireBootstrappedClient(client, "orgs");
-			return unwrapCapxulResult(await bootstrappedClient.orgs(), bootstrappedClient._internal.telemetry);
+			return unwrapCapxulResult(await requireBootstrappedClient(client, "orgs").orgs());
 		},
 		enabled: client !== null && (options?.enabled ?? true)
 	});
@@ -658,8 +485,7 @@ function useCapxulOrgMembers(orgId, options) {
 		queryKey: capxulKeys.orgMembers(orgId),
 		queryFn: async () => {
 			if (orgId === void 0) throw Errors.invalidInput("orgId", "required for useCapxulOrgMembers");
-			const bootstrappedClient = requireBootstrappedClient(client, "org.members");
-			return unwrapCapxulResult(await bootstrappedClient.org(orgId).members(), bootstrappedClient._internal.telemetry);
+			return unwrapCapxulResult(await requireBootstrappedClient(client, "org.members").org(orgId).members());
 		},
 		enabled: client !== null && enabled && orgId !== void 0
 	});
@@ -673,8 +499,7 @@ function useCapxulOrgRoles(orgId, options) {
 		queryKey: capxulKeys.orgRoles(orgId),
 		queryFn: async () => {
 			if (orgId === void 0) throw Errors.invalidInput("orgId", "required for useCapxulOrgRoles");
-			const bootstrappedClient = requireBootstrappedClient(client, "org.roles");
-			return unwrapCapxulResult(await bootstrappedClient.org(orgId).roles(), bootstrappedClient._internal.telemetry);
+			return unwrapCapxulResult(await requireBootstrappedClient(client, "org.roles").org(orgId).roles());
 		},
 		enabled: client !== null && enabled && orgId !== void 0
 	});
@@ -688,8 +513,7 @@ function useCapxulOrgTreasury(orgId, options) {
 		queryKey: capxulKeys.orgTreasury(orgId),
 		queryFn: async () => {
 			if (orgId === void 0) throw Errors.invalidInput("orgId", "required for useCapxulOrgTreasury");
-			const bootstrappedClient = requireBootstrappedClient(client, "org.treasury");
-			return unwrapCapxulResult(await bootstrappedClient.org(orgId).treasury(), bootstrappedClient._internal.telemetry);
+			return unwrapCapxulResult(await requireBootstrappedClient(client, "org.treasury").org(orgId).treasury());
 		},
 		enabled: client !== null && enabled && orgId !== void 0
 	});
@@ -701,8 +525,7 @@ function useCapxulCreateOrg() {
 	const queryClient = useQueryClient();
 	return useMutation({
 		mutationFn: async (input) => {
-			const bootstrappedClient = requireBootstrappedClient(client, "createOrg");
-			return unwrapCapxulResult(await bootstrappedClient.createOrg(input), bootstrappedClient._internal.telemetry, "mutation");
+			return unwrapCapxulResult(await requireBootstrappedClient(client, "createOrg").createOrg(input));
 		},
 		onSuccess: async () => {
 			await queryClient.invalidateQueries({ queryKey: capxulKeys.orgs });
@@ -717,8 +540,7 @@ function useCapxulInviteMember(orgId) {
 	return useMutation({
 		mutationFn: async (input) => {
 			if (orgId === void 0) throw Errors.invalidInput("orgId", "required for useCapxulInviteMember");
-			const bootstrappedClient = requireBootstrappedClient(client, "org.invite");
-			return unwrapCapxulResult(await bootstrappedClient.org(orgId).invite(input), bootstrappedClient._internal.telemetry, "mutation");
+			return unwrapCapxulResult(await requireBootstrappedClient(client, "org.invite").org(orgId).invite(input));
 		},
 		onSuccess: async () => {
 			if (orgId === void 0) return;
@@ -973,8 +795,7 @@ function useCapxulUsernameAvailability(username, options) {
 	return useQuery({
 		queryKey: capxulKeys.usernameAvailability(candidate),
 		queryFn: async () => {
-			const bootstrappedClient = requireBootstrappedClient(client, "identity.usernameAvailable");
-			return unwrapCapxulResult(await bootstrappedClient.identity.usernameAvailable(candidate), bootstrappedClient._internal.telemetry);
+			return unwrapCapxulResult(await requireBootstrappedClient(client, "identity.usernameAvailable").identity.usernameAvailable(candidate));
 		},
 		enabled: client !== null && candidate.length >= 3 && (options?.enabled ?? true)
 	});
@@ -992,15 +813,13 @@ function useCapxulImageUpload() {
 	const queryClient = useQueryClient();
 	return useMutation({
 		mutationFn: async ({ blob, target }) => {
-			const bootstrappedClient = requireBootstrappedClient(client, "media.uploadImage");
-			const media = bootstrappedClient.media;
-			const telemetry = bootstrappedClient._internal.telemetry;
-			const uploaded = unwrapCapxulResult(await media.uploadImage(blob), telemetry);
-			if (target.kind === "profile") return { url: unwrapCapxulResult(await media.setProfileImage({ storageId: uploaded.storageId }), telemetry).imageUrl };
+			const media = requireBootstrappedClient(client, "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
-			}), telemetry).logoUrl };
+			})).logoUrl };
 		},
 		onSuccess: async (_value, input) => {
 			await queryClient.invalidateQueries({ queryKey: input.target.kind === "profile" ? capxulKeys.profile : capxulKeys.orgs });
@@ -1008,4 +827,733 @@ function useCapxulImageUpload() {
 	});
 }
 //#endregion
-export { CapxulAuthenticationController, CapxulOnboardingController, CapxulProvider, acknowledgeOnboardingDestination, activeOnboardingRecovery, clearOnboardingJourney, currentOnboardingJourneyId, entered, invalidateOnboardingJourneyObservation, loadOnboardingJourney, onboardingJourneyPosition, saveOnboardingJourney, startOnboardingJourney, useCapxul, useCapxulAccountBalance, useCapxulAccountFund, useCapxulActivity, useCapxulActivityDetail, useCapxulAnnotateMovement, useCapxulAuth, useCapxulCancelPayment, useCapxulClaimPayment, useCapxulClientOrNull, useCapxulCreateCommitment, useCapxulCreateOrg, useCapxulDestination, useCapxulHoldings, useCapxulIdentity, useCapxulImageUpload, useCapxulInviteMember, useCapxulOrgMembers, useCapxulOrgRoles, useCapxulOrgTreasury, useCapxulOrganizationPay, useCapxulOrganizationPayBatch, useCapxulOrgs, useCapxulPay, useCapxulPayment, useCapxulPayments, useCapxulPermission, useCapxulPermissionAssign, useCapxulPermissionChange, useCapxulPermissionCreate, useCapxulPermissionReplace, useCapxulPermissionRevoke, useCapxulPermissions, useCapxulProfile, useCapxulRedirectPayment, useCapxulSend, useCapxulTransitions, useCapxulUsernameAvailability };
+//#region src/headless/contacts/use-contacts.ts
+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}`);
+			return unwrapCapxulResult(command.kind === "rename" ? await target.label({
+				entryId: command.id,
+				label: command.name
+			}) : command.kind === "hide" ? await target.hide(command.id) : await target.unhide(command.id));
+		},
+		onSettled: invalidate,
+		onError: onFailed
+	}).mutate;
+	const [value, setValue] = useState("");
+	const [addError, setAddError] = useState(null);
+	const addContact = useMutation({
+		mutationFn: async (ref) => unwrapCapxulResult(await requireBook(book, "addressBook.add").add({ ref })),
+		onSettled: invalidate
+	});
+	const addMutate = addContact.mutate;
+	const blockedReason = refusal !== null ? "org-unavailable" : value.trim() === "" ? "empty" : null;
+	const submitGate = useRef(false);
+	const submit = useCallback(() => {
+		if (blockedReason !== null || submitGate.current) return;
+		submitGate.current = true;
+		setAddError(null);
+		addMutate(refFromTypedText(value), {
+			onSuccess: (entry) => {
+				setValue("");
+				onAdded(toContact(entry));
+			},
+			onError: (error) => {
+				setAddError(error.code === "INVALID_INPUT" ? "unresolved" : "failed");
+				onFailed(error);
+			},
+			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) => writeMutate({
+			kind: "rename",
+			id,
+			name
+		}), [writeMutate]),
+		hide: useCallback((id) => writeMutate({
+			kind: "hide",
+			id
+		}), [writeMutate]),
+		unhide: useCallback((id) => writeMutate({
+			kind: "unhide",
+			id
+		}), [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 includeHidden = options.show === "all";
+	const { book, refusal } = engine;
+	const query = useQuery({
+		queryKey: capxulKeys.contactsList(engine.scope, includeHidden),
+		queryFn: async () => unwrapCapxulResult(await requireBook(book, "addressBook.list").list({ includeHidden })),
+		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) => rename(entry.id, name),
+				hide: () => hide(entry.id),
+				unhide: () => unhide(entry.id)
+			}));
+		}, [
+			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/headless/contacts/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$3({ actor, onAdded, onFailed, children }) {
+	const engine = useContacts({
+		actor,
+		onAdded,
+		onFailed
+	});
+	return /* @__PURE__ */ jsx(ContactsContext.Provider, {
+		value: engine,
+		children
+	});
+}
+function Summary({ 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$3, {
+	Summary,
+	List,
+	Add
+});
+//#endregion
+//#region src/headless/send-money/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/headless/send-money/use-recipient-resolution.ts
+function toTargetReference(method, text) {
+	const trimmed = text.trim();
+	if (trimmed === "") return null;
+	return method === "username" ? {
+		kind: "handle",
+		handle: trimmed.replace(/^@/, "")
+	} : {
+		kind: "email",
+		email: trimmed
+	};
+}
+/** How long the engine waits after the last keystroke before resolving. */
+const RESOLVE_DEBOUNCE_MS = 400;
+function useRecipientResolution(client) {
+	const [method, setMethodState] = useState("email-address");
+	const [text, setText] = useState("");
+	const reference = useMemo(() => toTargetReference(method, text), [method, text]);
+	const debouncedReference = useDebouncedValue(reference, RESOLVE_DEBOUNCE_MS);
+	const [outcome, setOutcome] = useState(null);
+	useEffect(() => {
+		if (debouncedReference === null || client === null) {
+			setOutcome(null);
+			return;
+		}
+		const controller = new AbortController();
+		setOutcome({
+			reference: debouncedReference,
+			status: "checking",
+			target: null
+		});
+		client.targets.resolve(debouncedReference, { signal: controller.signal }).then((result) => {
+			if (controller.signal.aborted) return;
+			setOutcome(result.ok ? {
+				reference: debouncedReference,
+				status: "found",
+				target: result.value
+			} : {
+				reference: debouncedReference,
+				status: result.error.code === "INVALID_INPUT" ? "not-found" : "failed",
+				target: null
+			});
+		});
+		return () => controller.abort();
+	}, [client, debouncedReference]);
+	const setMethod = useCallback((next) => {
+		setMethodState(next);
+		setText("");
+	}, []);
+	const settled = outcome !== null && outcome.reference === debouncedReference ? outcome : null;
+	const status = reference === null ? "empty" : reference !== debouncedReference || settled === null ? "checking" : settled.status;
+	const resolvedTarget = status === "found" ? settled?.target ?? null : null;
+	return {
+		slice: {
+			method,
+			setMethod,
+			value: text,
+			change: setText,
+			status,
+			label: resolvedTarget?.label ?? null
+		},
+		resolvedTarget,
+		trimmed: text.trim()
+	};
+}
+//#endregion
+//#region src/headless/send-money/use-send-money.ts
+function useSendMoney(input) {
+	const { actor, onSent, onFailed } = input;
+	const client = useCapxulClientOrNull();
+	const signerStatus = useSignerStatus(client);
+	const balance = useCapxulAccountBalance({ enabled: actor.kind === "personal" });
+	const account = actor.kind === "personal" ? balance.data ?? null : null;
+	const assetOptions = useMemo(() => account === null ? [] : [{
+		id: account.id,
+		symbol: account.available.currency,
+		availableDisplay: formatMoney(account.available, { grammar: "code" })
+	}], [account]);
+	const [selectedAssetId, setSelectedAssetId] = useState(null);
+	useEffect(() => {
+		if (!assetOptions.some((option) => option.id === selectedAssetId)) setSelectedAssetId(assetOptions[0]?.id ?? null);
+	}, [assetOptions, selectedAssetId]);
+	const selectedAssetOption = assetOptions.find((option) => option.id === selectedAssetId) ?? null;
+	const selectedAssetMoney = selectedAssetOption !== null && account !== null ? account.available : null;
+	const selectAsset = useCallback((id) => {
+		setSelectedAssetId((current) => assetOptions.some((option) => option.id === id) ? id : current);
+	}, [assetOptions]);
+	const [amountText, setAmountText] = useState("");
+	const parsed = useMemo(() => selectedAssetMoney === null || amountText.trim() === "" ? null : parseMoney(amountText, selectedAssetMoney), [amountText, selectedAssetMoney]);
+	const parsedMoney = parsed !== null && !isMoneyParseError(parsed) ? parsed : null;
+	const amountError = parsed !== null && isMoneyParseError(parsed) ? parsed.reason : null;
+	const recipient = useRecipientResolution(client);
+	const resolvedTarget = recipient.resolvedTarget;
+	const pay = useCapxulPay();
+	const blockedReason = signerStatus !== "ready" ? "signer-not-ready" : actor.kind === "organization" ? "no-source" : selectedAssetOption === null ? "no-asset" : parsedMoney === null ? "amount-invalid" : resolvedTarget === null ? "recipient-unresolved" : null;
+	const submitGate = useRef(false);
+	const submit = useCallback(() => {
+		if (blockedReason !== null || submitGate.current) return;
+		if (parsedMoney === null || resolvedTarget === null) return;
+		submitGate.current = true;
+		const amount = parsedMoney;
+		const sentRecipient = recipient.trimmed;
+		pay.mutate({
+			to: resolvedTarget.reference,
+			amount
+		}, {
+			onSuccess: (payment) => onSent({
+				payment,
+				amount,
+				recipient: sentRecipient
+			}),
+			onError: (error) => onFailed(error),
+			onSettled: () => {
+				submitGate.current = false;
+			}
+		});
+	}, [
+		blockedReason,
+		onFailed,
+		onSent,
+		parsedMoney,
+		pay,
+		recipient.trimmed,
+		resolvedTarget
+	]);
+	return {
+		asset: {
+			options: assetOptions,
+			selected: selectedAssetOption,
+			select: selectAsset,
+			error: actor.kind === "personal" && balance.error !== null ? "read-failed" : null
+		},
+		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/headless/send-money/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$2({ actor, onSent, onFailed, children }) {
+	const engine = useSendMoney({
+		actor,
+		onSent,
+		onFailed
+	});
+	return /* @__PURE__ */ jsx(SendMoneyContext.Provider, {
+		value: engine,
+		children
+	});
+}
+function Asset({ 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({ children }) {
+	return /* @__PURE__ */ jsx(Fragment, { children: children(useSendMoneyContext().actions) });
+}
+/** The compound shape the app's own design system already uses (`StatusTabs`). */
+const CapxulSendMoney = Object.assign(Root$2, {
+	Asset,
+	Amount,
+	Recipient,
+	Actions
+});
+//#endregion
+//#region src/headless/access/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;
+	}
+}
+/**
+* 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 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(orgId),
+		queryFn: async () => {
+			return unwrapCapxulResult(await requireBootstrappedClient(client, "org.me").org(orgId).me());
+		},
+		enabled: ready && orgId !== void 0
+	});
+	const reading = 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
+	]);
+	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$1({ 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$1, {
+	Can,
+	Standing
+});
+//#endregion
+//#region src/headless/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" });
+}
+/**
+* Whether the Organization lane has reached a position that names a real
+* screen. `isRestoring` deliberately leaves this question to the gate (#1518),
+* because every org lane sits under a claimed account and `destination()`
+* already names a screen for each of its positions — except `loading`, which
+* means "still finding out" and whose destination is the provisioning screen.
+*
+* NEGATIVE classification, the same discipline `isRestoring` uses: only the
+* settled positions are enumerated, so a lane position added later HOLDS the
+* gate instead of bouncing a member who is in fact inside a ready Organization.
+* It gates the REDIRECT only, never the grant, so it can never blank a screen
+* the probes have already said yes to.
+*/
+function isOrgLaneSettled(identity) {
+	if (identity.phase !== "authenticated" || identity.account.at !== "claimed") return true;
+	const org = identity.account.org;
+	if (org === null) return true;
+	switch (org.at) {
+		case "ready":
+		case "failed": return true;
+		default: return false;
+	}
+}
+/** 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?.status === "ready" || lifecycle?.status === "failed";
+}
+function destinationOrNull(identity) {
+	return identity === null ? null : resolveIdentityDestination(identity);
+}
+function isClaimedOrFalse(identity) {
+	return identity !== null && isClaimed$1(identity);
+}
+/**
+* The branch, as one pure decision over four settled facts.
+*
+* The order is the frozen one: an error wins over everything, an unsettled
+* probe holds, and only then does the judgment speak. The last two arms are the
+* whole bug class the deleted app guard kept re-fixing — a destination is
+* obeyed only once every lane that could still change it has settled, and
+* anything else HOLDS rather than guessing.
+*/
+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";
+}
+/** The engine — all the logic. NOT exported from the package barrel. */
+function useDashboardAccess(scope) {
+	const client = useCapxulClientOrNull();
+	const identity = useCapxulIdentityOrNull();
+	const destination = useMemo(() => destinationOrNull(identity), [identity]);
+	const orgId = scope.kind === "organization" ? scope.orgId : void 0;
+	const claimed = isClaimedOrFalse(identity);
+	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 ?? []).some((organization) => String(organization.id) === orgId);
+	const wantsLifecycle = wantsMemberships && membershipsSettled && hasMembership;
+	const lifecycle = useQuery({
+		queryKey: capxulKeys.orgLifecycle(orgId),
+		queryFn: async () => {
+			return unwrapCapxulResult(await requireBootstrappedClient(client, "org.getLifecycle").org(orgId).getLifecycle());
+		},
+		enabled: wantsLifecycle && client !== null
+	});
+	const lifecycleError = wantsLifecycle ? lifecycle.error : null;
+	const lifecycleSettled = !wantsLifecycle || lifecycleError !== null || isLifecycleSettled(lifecycle.data);
+	const retry = useCallback(() => {
+		if (sessionError !== null && client !== null) client.auth.getSession();
+		if (membershipError !== null) memberships.refetch();
+		if (lifecycleError !== null) lifecycle.refetch();
+	}, [
+		client,
+		sessionError,
+		membershipError,
+		lifecycleError,
+		memberships.refetch,
+		lifecycle.refetch
+	]);
+	const error = sessionError ?? membershipError ?? lifecycleError;
+	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(lifecycle.data, orgId),
+		orgLaneSettled: identity !== null && isOrgLaneSettled(identity),
+		destination
+	});
+	return useMemo(() => ({
+		phase,
+		error,
+		destination,
+		retry
+	}), [
+		phase,
+		error,
+		destination,
+		retry
+	]);
+}
+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({ 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) return null;
+	return /* @__PURE__ */ jsx(Fragment, { children: children({
+		error: state.error,
+		retry: state.retry
+	}) });
+}
+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, {
+	Checking,
+	Error: DashboardError,
+	Redirect,
+	Granted
+});
+//#endregion
+export { CapxulAuthenticationController, CapxulContacts, CapxulDashboardAccess, CapxulOnboardingController, CapxulOrgMember, CapxulProvider, CapxulSendMoney, acknowledgeOnboardingDestination, activeOnboardingRecovery, clearOnboardingJourney, currentOnboardingJourneyId, entered, invalidateOnboardingJourneyObservation, isClaimed, isRestoring, loadOnboardingJourney, onboardingJourneyPosition, saveOnboardingJourney, startOnboardingJourney, useCapxul, useCapxulAccountBalance, useCapxulAccountFund, useCapxulActivity, useCapxulActivityDetail, useCapxulAnnotateMovement, useCapxulAuth, useCapxulCancelPayment, useCapxulClaimPayment, useCapxulClientOrNull, useCapxulCreateCommitment, useCapxulCreateOrg, useCapxulDestination, useCapxulHoldings, useCapxulIdentity, useCapxulImageUpload, useCapxulInviteMember, useCapxulOrgMembers, useCapxulOrgRoles, useCapxulOrgTreasury, useCapxulOrganizationPay, useCapxulOrganizationPayBatch, useCapxulOrgs, useCapxulPay, useCapxulPayment, useCapxulPayments, useCapxulPermission, useCapxulPermissionAssign, useCapxulPermissionChange, useCapxulPermissionCreate, useCapxulPermissionReplace, useCapxulPermissionRevoke, useCapxulPermissions, useCapxulProfile, useCapxulRedirectPayment, useCapxulSend, useCapxulTransitions, useCapxulUsernameAvailability };