@capxul/sdk-react 1.0.0-alpha.9 → 1.1.0

package/README.md

@@ -0,0 +1,60 @@
+# `@capxul/sdk-react`
+
+The React projection over `@capxul/sdk`. It owns provider lifecycle, the one
+canonical identity projection, renderer-neutral identity controllers, TanStack
+Query bindings for rich data, and authenticated-cache cleanup.
+
+```tsx
+"use client";
+
+import { CapxulProvider } from "@capxul/sdk-react";
+
+export function Providers({ children }: { children: React.ReactNode }) {
+  return (
+    <CapxulProvider publishableKey={process.env.NEXT_PUBLIC_CAPXUL_PUBLISHABLE_KEY!}>
+      {children}
+    </CapxulProvider>
+  );
+}
+```
+
+## Public shape
+
+- `useCapxulIdentity`, `useCapxulDestination`, and `useCapxulTransitions`
+  expose the Core SDK identity actor without a parallel React state model.
+- `useCapxulSend` carries caller-owned invocation controls to that actor.
+- `useCapxulAuth` is the stable six-verb application facade.
+- `CapxulAuthenticationController` and `CapxulOnboardingController` select
+  app-owned slots and render no SDK-owned DOM.
+- Rich-data hooks such as `useCapxulProfile`, `useCapxulOrgs`, members, roles,
+  treasury, and money hooks remain TanStack Query projections.
+
+The packed npm package exposes `@capxul/sdk-react` and
+`@capxul/sdk-react/testing`. The workspace-only `@capxul/sdk-react/headless`
+subpath is not published.
+
+```tsx
+import { createCapxulReactTestHarness } from "@capxul/sdk-react/testing";
+
+const harness = createCapxulReactTestHarness();
+const tree = harness.provider(harness.authentication(slots));
+await harness.testing.close();
+```
+
+The testing harness uses the real public provider and controllers and imports
+its client factory only through `@capxul/sdk/testing`; it owns no renderer or
+parallel identity state.
+
+## Documentation
+
+- [Maintainer context](./CONTEXT.md)
+- [Architecture](./docs/architecture.md)
+- [Proof map](./docs/proof.md)
+
+## Development
+
+```bash
+vp run --filter @capxul/sdk-react check-types
+vp run --filter @capxul/sdk-react test
+(cd packages/sdk-react && vp pack)
+```

package/dist/controllers-BU11km12.mjs

@@ -0,0 +1,647 @@
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
+import { QueryClient, QueryClientProvider, useQueryClient } from "@tanstack/react-query";
+import { createCapxulClient, isCapxulError, resolveIdentityDestination, toCountryCode } from "@capxul/sdk";
+import { jsx } from "react/jsx-runtime";
+//#region src/internal/capxul-bootstrap-context.tsx
+const CapxulBootstrapContext = createContext(null);
+function CapxulBootstrapProvider({ value, children }) {
+	return /* @__PURE__ */ jsx(CapxulBootstrapContext.Provider, {
+		value,
+		children
+	});
+}
+function useCapxul() {
+	const state = useContext(CapxulBootstrapContext);
+	if (state === null) throw new Error("useCapxul must be used within <CapxulProvider>");
+	return state;
+}
+//#endregion
+//#region src/internal/capxul-client-context.tsx
+const MISSING_CAPXUL_CLIENT_PROVIDER = Symbol("MISSING_CAPXUL_CLIENT_PROVIDER");
+const CapxulClientContext = createContext(MISSING_CAPXUL_CLIENT_PROVIDER);
+function CapxulClientProvider({ client, children }) {
+	return /* @__PURE__ */ jsx(CapxulClientContext.Provider, {
+		value: client,
+		children
+	});
+}
+/**
+* Returns the client, or `null` while `<CapxulProvider>` is still bootstrapping.
+* Data hooks use this so they can sit in `isPending` (disabled query) until the
+* client resolves, rather than throwing during bootstrap.
+*/
+function useCapxulClientOrNull() {
+	const client = useContext(CapxulClientContext);
+	if (client === MISSING_CAPXUL_CLIENT_PROVIDER) throw new Error("useCapxulClient must be used within <CapxulProvider>");
+	return client;
+}
+//#endregion
+//#region src/internal/reactivity-keys.ts
+const capxulKeys = {
+	root: ["capxul"],
+	profile: ["capxul", "profile"],
+	usernameAvailability: (username) => [
+		"capxul",
+		"profile",
+		"username-availability",
+		username
+	],
+	account: ["capxul", "account"],
+	provisioning: ["capxul", "provisioning"],
+	binding: ["capxul", "binding"],
+	accountBalance: ["capxul", "accountBalance"],
+	subAccounts: (accountId) => [
+		"capxul",
+		"subAccounts",
+		accountId ?? "pending"
+	],
+	orgs: ["capxul", "orgs"],
+	org: (orgId) => [
+		"capxul",
+		"org",
+		orgId ?? "pending"
+	],
+	orgMembers: (orgId) => [
+		"capxul",
+		"org",
+		orgId ?? "pending",
+		"members"
+	],
+	orgRoles: (orgId) => [
+		"capxul",
+		"org",
+		orgId ?? "pending",
+		"roles"
+	],
+	orgTreasury: (orgId) => [
+		"capxul",
+		"org",
+		orgId ?? "pending",
+		"treasury"
+	],
+	payments: ["capxul", "payments"],
+	payment: (paymentId) => [
+		"capxul",
+		"payments",
+		paymentId ?? "pending"
+	]
+};
+//#endregion
+//#region src/identity.tsx
+const MISSING_IDENTITY_PROVIDER = Symbol("MISSING_IDENTITY_PROVIDER");
+const IdentityContext = createContext(MISSING_IDENTITY_PROVIDER);
+function controls(options) {
+	if (options === void 0) return void 0;
+	return {
+		...options.signal === void 0 ? {} : { signal: options.signal },
+		...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs },
+		...options.deadlineMs === void 0 ? {} : { deadlineMs: options.deadlineMs },
+		...options.correlationId === void 0 ? {} : { correlation_id: options.correlationId },
+		...options.journeyId === void 0 ? {} : { journey_id: options.journeyId }
+	};
+}
+const failure = (result) => result.ok ? null : {
+	ok: false,
+	reason: result.refused
+};
+async function guarded(runtime, verb, options, run) {
+	const invocation = controls(options);
+	try {
+		return await (runtime.runFacade?.(verb, invocation, run) ?? run(invocation));
+	} catch {
+		return {
+			ok: false,
+			reason: "UNKNOWN"
+		};
+	}
+}
+const ORGANIZATION_HANDLE = /^[a-z0-9-]{3,32}$/;
+function normalizeOrganization(organization) {
+	const name = typeof organization.name === "string" ? organization.name.trim() : "";
+	const handle = typeof organization.handle === "string" ? organization.handle.trim().toLowerCase() : "";
+	if (name.length === 0 || !ORGANIZATION_HANDLE.test(handle)) return null;
+	if (organization.bio !== void 0 && typeof organization.bio !== "string") return null;
+	if (organization.size !== void 0 && typeof organization.size !== "string") return null;
+	try {
+		return {
+			name,
+			handle,
+			country: toCountryCode(organization.country),
+			...organization.bio === void 0 ? {} : { bio: organization.bio },
+			...organization.size === void 0 ? {} : { size: organization.size }
+		};
+	} catch {
+		return null;
+	}
+}
+function createAuth(client, clearAuthenticatedQueries) {
+	const runtime = client._internal.identity;
+	const read = async (invocation) => {
+		return failure(await runtime.send({ _tag: "ReadSession" }, invocation)) ?? { ok: true };
+	};
+	const ensureAccount = async (invocation) => {
+		return failure(await runtime.send({ _tag: "EnsureAccount" }, invocation)) ?? { ok: true };
+	};
+	const reachClaimed = async (invocation) => {
+		let state = runtime.snapshot();
+		if (state.phase !== "authenticated" || state.account.at === "unknown") {
+			const result = await runtime.send({ _tag: "EnsureAccount" }, invocation);
+			const refused = failure(result);
+			if (refused !== null) return refused;
+			state = result.state;
+		}
+		if (state.phase !== "authenticated") return {
+			ok: false,
+			reason: "WRONG_STATE"
+		};
+		if (state.account.at === "claimed") return { ok: true };
+		const event = state.account.at === "failed" ? { _tag: "RetryAccount" } : state.account.at === "counterfactual" ? { _tag: "ClaimAccount" } : { _tag: "EnsureAccount" };
+		const result = await runtime.send(event, invocation);
+		const refused = failure(result);
+		if (refused !== null) return refused;
+		const next = result.state;
+		return next.phase === "authenticated" && next.account.at === "claimed" ? { ok: true } : {
+			ok: false,
+			reason: "WRONG_STATE"
+		};
+	};
+	const completeProfile = async (profile, invocation) => {
+		const result = await runtime.completeProfile(profile, invocation);
+		return result.ok ? { ok: true } : result;
+	};
+	return {
+		requestCode: (email, options) => guarded(runtime, "requestCode", options, async (invocation) => {
+			const result = await client.auth.signIn({ email }, invocation);
+			if (!result.ok) return {
+				ok: false,
+				reason: result.error.code
+			};
+			const state = runtime.snapshot();
+			return state.phase === "otp_pending" ? {
+				ok: true,
+				requestedAt: state.requestedAt
+			} : {
+				ok: false,
+				reason: state.phase === "faulted" ? state.failure.code : "UNKNOWN"
+			};
+		}),
+		verifyCode: (otp, options) => guarded(runtime, "verifyCode", options, async (invocation) => {
+			const state = runtime.snapshot();
+			const email = state.phase === "otp_pending" ? state.email : state.phase === "faulted" && state.resume !== null ? state.resume.email : "";
+			if (!/^\d{6}$/.test(otp)) return failure(await runtime.send({
+				_tag: "VerifyOtp",
+				email,
+				otp,
+				now: Date.now()
+			}, invocation)) ?? {
+				ok: false,
+				reason: "UNKNOWN"
+			};
+			const result = await client.auth.verifyOtp({
+				email,
+				code: otp
+			}, invocation);
+			if (!result.ok) return {
+				ok: false,
+				reason: result.error.code
+			};
+			const next = runtime.snapshot();
+			return next.phase === "authenticated" ? {
+				ok: true,
+				authUserId: next.session.authUserId,
+				profileComplete: next.profileComplete
+			} : {
+				ok: false,
+				reason: next.phase === "faulted" ? next.failure.code : "UNKNOWN"
+			};
+		}),
+		signOut: (options) => guarded(runtime, "signOut", options, async (invocation) => {
+			const result = await client.auth.signOut(invocation);
+			if (!result.ok) return {
+				ok: false,
+				reason: result.error.code
+			};
+			await clearAuthenticatedQueries();
+			return { ok: true };
+		}),
+		completePersonal: (profile, options) => guarded(runtime, "completePersonal", options, async (invocation) => {
+			const completed = await completeProfile(profile, invocation);
+			if (!completed.ok) return completed;
+			const refreshed = await read(invocation);
+			if (!refreshed.ok) return refreshed;
+			return ensureAccount(invocation);
+		}),
+		createOrganization: (submission, options) => guarded(runtime, "createOrganization", options, async (invocation) => {
+			const organization = normalizeOrganization(submission.organization);
+			if (organization === null) return {
+				ok: false,
+				reason: "INVALID_INPUT"
+			};
+			const completed = await completeProfile(submission.profileDetails, invocation);
+			if (!completed.ok) return completed;
+			const refreshed = await read(invocation);
+			if (!refreshed.ok) return refreshed;
+			const claimed = await reachClaimed(invocation);
+			if (!claimed.ok) return claimed;
+			const created = await runtime.send({
+				_tag: "CreateOrganization",
+				draft: organization
+			}, invocation);
+			const refused = failure(created);
+			if (refused !== null) return refused;
+			const state = created.state;
+			const org = state.phase === "authenticated" && state.account.at === "claimed" ? state.account.org : null;
+			return org !== null && org.at !== "creating" && org.orgId !== null ? {
+				ok: true,
+				orgId: org.orgId
+			} : {
+				ok: false,
+				reason: "UNKNOWN"
+			};
+		}),
+		retry: (options) => guarded(runtime, "retry", options, async (invocation) => {
+			const state = runtime.snapshot();
+			const event = state.phase === "authenticated" && state.account.at === "claimed" ? { _tag: "RetryOrganization" } : { _tag: "RetryAccount" };
+			return failure(await runtime.send(event, invocation)) ?? { ok: true };
+		})
+	};
+}
+function CapxulIdentityProvider({ client, children }) {
+	const queryClient = useQueryClient();
+	const runtime = client?._internal.identity ?? null;
+	const listeners = useRef(/* @__PURE__ */ new Set());
+	useEffect(() => {
+		if (client === null) return;
+		Promise.resolve().then(() => client.auth.getSession()).catch(() => void 0);
+	}, [client]);
+	useEffect(() => {
+		if (runtime === null) return;
+		return runtime.subscribeTransitions((record) => {
+			const state = runtime.snapshot();
+			for (const listener of listeners.current) try {
+				listener(record, state);
+			} catch {
+				listeners.current.delete(listener);
+			}
+		});
+	}, [runtime]);
+	const addTransitionListener = useCallback((listener) => {
+		listeners.current.add(listener);
+		return () => listeners.current.delete(listener);
+	}, []);
+	const value = useMemo(() => {
+		if (client === null || runtime === null) return null;
+		const send = (event, options) => runtime.send(event, controls(options));
+		const clearAuthenticatedQueries = async () => {
+			await queryClient.cancelQueries({ queryKey: capxulKeys.root });
+			await queryClient.resetQueries({ queryKey: capxulKeys.root });
+		};
+		return {
+			runtime,
+			send,
+			auth: createAuth(client, clearAuthenticatedQueries),
+			addTransitionListener
+		};
+	}, [
+		client,
+		runtime,
+		addTransitionListener,
+		queryClient
+	]);
+	return /* @__PURE__ */ jsx(IdentityContext.Provider, {
+		value,
+		children
+	});
+}
+function useIdentityContext() {
+	const value = useContext(IdentityContext);
+	if (value === MISSING_IDENTITY_PROVIDER) throw new Error("identity hooks must be used within <CapxulProvider>");
+	if (value === null) throw new Error("identity hooks require a ready <CapxulProvider>");
+	return value;
+}
+const noSubscribe = () => () => void 0;
+const noState = () => null;
+function useCapxulIdentityOrNull() {
+	const value = useContext(IdentityContext);
+	if (value === MISSING_IDENTITY_PROVIDER) throw new Error("identity hooks must be used within <CapxulProvider>");
+	return useSyncExternalStore(value?.runtime.subscribe ?? noSubscribe, value?.runtime.snapshot ?? noState, value?.runtime.snapshot ?? noState);
+}
+function useCapxulIdentity() {
+	const state = useCapxulIdentityOrNull();
+	if (state === null) throw new Error("identity hooks require a ready <CapxulProvider>");
+	return state;
+}
+function useCapxulSend() {
+	return useIdentityContext().send;
+}
+function useCapxulAuth() {
+	return useIdentityContext().auth;
+}
+function useCapxulDestination() {
+	const next = resolveIdentityDestination(useCapxulIdentity());
+	const held = useRef(null);
+	const key = JSON.stringify(next);
+	if (held.current?.key !== key) held.current = {
+		key,
+		value: next
+	};
+	return held.current.value;
+}
+function useCapxulTransitions(listener) {
+	const { addTransitionListener } = useIdentityContext();
+	useEffect(() => addTransitionListener(listener), [addTransitionListener, listener]);
+}
+const entered = (record, target) => record.outcome === "applied" && record.from !== target && record.to === target;
+//#endregion
+//#region src/provider.tsx
+/**
+* Transient failure codes worth a retry — network blips, rate limits, and
+* upstream provider/unknown hiccups that a later attempt may clear. Everything
+* else (including any future code) is deterministic and NOT retried: retrying a
+* deterministic failure only multiplies the failed backend actions. A fresh
+* user with no Safe yet hits `SMART_ACCOUNT_MISSING` on every attempt, so the
+* old blanket `retry: 2` tripled that (and every other deterministic) failed
+* action for zero benefit (#1031).
+*/
+const RETRYABLE_QUERY_ERROR_CODES = new Set([
+	"NETWORK_ERROR",
+	"RATE_LIMITED",
+	"PROVIDER_ERROR",
+	"UNKNOWN"
+]);
+/** Matches the previous `retry: 2` budget (initial attempt + up to 2 retries). */
+const MAX_CAPXUL_QUERY_RETRIES = 2;
+/**
+* TanStack `retry` predicate: `failureCount` is 0-indexed and checked before
+* increment, so `< MAX` reproduces the old numeric budget for retryable codes.
+* Exported for direct unit coverage of the deterministic-vs-transient split.
+*/
+function shouldRetryCapxulQuery(failureCount, error) {
+	if (failureCount >= MAX_CAPXUL_QUERY_RETRIES) return false;
+	return isCapxulError(error) && RETRYABLE_QUERY_ERROR_CODES.has(error.code);
+}
+/**
+* The default query client used when the host injects none. Exported so a test
+* can pin that `queries.retry` is wired to `shouldRetryCapxulQuery` — reverting
+* it to the old blanket `retry: 2` must fail a test (#1031).
+*/
+function makeDefaultQueryClient() {
+	return new QueryClient({ defaultOptions: {
+		queries: {
+			retry: shouldRetryCapxulQuery,
+			staleTime: 3e4
+		},
+		mutations: { retry: 0 }
+	} });
+}
+function isCapxulQueryKey(queryKey) {
+	return queryKey[0] === "capxul";
+}
+function clearClientScopedQueries(queryClient, ownsQueryClient) {
+	if (ownsQueryClient) {
+		queryClient.clear();
+		return;
+	}
+	queryClient.removeQueries({ predicate: (query) => isCapxulQueryKey(query.queryKey) });
+}
+function CapxulProvider(props) {
+	const { publishableKey, client: injectedClient, requirement, signer, observation, telemetry, queryClient, children } = props;
+	const [resolvedQueryClient] = useState(() => queryClient ?? makeDefaultQueryClient());
+	const [ownsQueryClient] = useState(() => queryClient === void 0);
+	const [attempt, setAttempt] = useState(0);
+	const retry = useCallback(() => {
+		setAttempt((n) => n + 1);
+	}, []);
+	const bootstrapInput = useMemo(() => publishableKey === void 0 ? null : {
+		publishableKey,
+		...requirement === void 0 ? {} : { requirement },
+		...signer === void 0 ? {} : { signer },
+		...observation === void 0 ? {} : { observation },
+		...telemetry === void 0 ? {} : { telemetry }
+	}, [
+		publishableKey,
+		requirement,
+		signer,
+		observation,
+		telemetry,
+		attempt
+	]);
+	const [ownedBootstrap, setOwnedBootstrap] = useState(null);
+	const activeOwnedBootstrap = bootstrapInput !== null && ownedBootstrap?.input === bootstrapInput ? ownedBootstrap : null;
+	const client = injectedClient ?? activeOwnedBootstrap?.client ?? null;
+	const previousClientRef = useRef(injectedClient ?? null);
+	useEffect(() => {
+		if (bootstrapInput === null) return;
+		let cancelled = false;
+		let created = null;
+		setOwnedBootstrap({
+			input: bootstrapInput,
+			client: null,
+			status: "bootstrapping",
+			error: null
+		});
+		(async () => {
+			const result = await createCapxulClient(bootstrapInput);
+			if (cancelled) {
+				if (result.ok) await result.value._internal.close?.();
+				return;
+			}
+			if (result.ok) {
+				created = result.value;
+				setOwnedBootstrap({
+					input: bootstrapInput,
+					client: result.value,
+					status: "ready",
+					error: null
+				});
+			} else setOwnedBootstrap({
+				input: bootstrapInput,
+				client: null,
+				status: "error",
+				error: result.error
+			});
+		})();
+		return () => {
+			cancelled = true;
+			created?._internal.close?.();
+		};
+	}, [bootstrapInput]);
+	useEffect(() => {
+		const previous = previousClientRef.current;
+		if (previous !== null && previous !== client) clearClientScopedQueries(resolvedQueryClient, ownsQueryClient);
+		previousClientRef.current = client;
+	}, [
+		client,
+		ownsQueryClient,
+		resolvedQueryClient
+	]);
+	const bootstrapState = useMemo(() => ({
+		status: injectedClient === void 0 ? activeOwnedBootstrap?.status ?? "bootstrapping" : "ready",
+		error: injectedClient === void 0 ? activeOwnedBootstrap?.error ?? null : null,
+		retry
+	}), [
+		activeOwnedBootstrap,
+		injectedClient,
+		retry
+	]);
+	if (publishableKey === void 0 === (injectedClient === void 0)) throw new Error("CapxulProvider requires exactly one of `publishableKey` or `client`");
+	return /* @__PURE__ */ jsx(QueryClientProvider, {
+		client: resolvedQueryClient,
+		children: /* @__PURE__ */ jsx(CapxulBootstrapProvider, {
+			value: bootstrapState,
+			children: /* @__PURE__ */ jsx(CapxulClientProvider, {
+				client,
+				children: /* @__PURE__ */ jsx(CapxulIdentityProvider, {
+					client,
+					children
+				})
+			})
+		})
+	});
+}
+//#endregion
+//#region src/controllers.tsx
+const action = async (send, event) => {
+	const result = await send(event);
+	return result.ok ? { ok: true } : {
+		ok: false,
+		reason: result.refused
+	};
+};
+function CapxulAuthenticationController({ slots }) {
+	const state = useCapxulIdentity();
+	const destination = useCapxulDestination();
+	const auth = useCapxulAuth();
+	const send = useCapxulSend();
+	switch (state.phase) {
+		case "signed_out": return slots.email({
+			state,
+			requestCode: auth.requestCode
+		});
+		case "otp_pending": return slots.otp({
+			state,
+			verifyCode: auth.verifyCode,
+			back: () => action(send, { _tag: "Reset" })
+		});
+		case "otp_sending":
+		case "otp_verifying":
+		case "signing_out": return slots.pending({ state });
+		case "faulted": return slots.failure({
+			state,
+			recover: () => action(send, state.resume === null ? { _tag: "Reset" } : {
+				_tag: "ResumeOtpEntry",
+				now: Date.now()
+			}),
+			back: () => action(send, { _tag: "Reset" })
+		});
+		case "authenticated": return slots.success({
+			state,
+			destination
+		});
+	}
+}
+function ready(destination) {
+	return destination?.to === "dashboardPersonal" || destination?.to === "dashboardOrganization";
+}
+function CapxulOnboardingController(props) {
+	const state = useCapxulIdentity();
+	const destination = useCapxulDestination();
+	const auth = useCapxulAuth();
+	if (state.phase !== "authenticated") return null;
+	const { slots, navigation } = props;
+	if (props.intent === null) return slots.intent({
+		state,
+		select: props.onIntent,
+		back: navigation.selectorBack
+	});
+	if (props.intent === "personal" && !state.profileComplete) return slots.profile({
+		intent: "personal",
+		state,
+		completePersonal: auth.completePersonal,
+		cancel: navigation.profileCancel
+	});
+	const submission = props.submittedOrganization;
+	if (props.intent === "organization" && props.organizationProfile === null && submission === null) return slots.profile({
+		intent: "organization",
+		state,
+		continueOrganization: props.onOrganizationProfile,
+		cancel: navigation.profileCancel
+	});
+	if (props.intent === "organization" && props.organizationProfile !== null && submission === null) return organizationForm(props, state, auth, null);
+	if (submission !== null && state.account.at !== "claimed") {
+		if (state.account.at === "failed") {
+			const retry = state.account.retryable ? (options) => auth.createOrganization(submission, options) : void 0;
+			return slots.accountFailure({
+				state,
+				account: state.account,
+				...retry === void 0 ? {} : { retry }
+			});
+		}
+		return slots.accountProgress({
+			state,
+			account: state.account
+		});
+	}
+	if (submission !== null && state.account.at === "claimed") {
+		const org = state.account.org;
+		if (org === null) return organizationForm(props, state, auth, submission);
+		if (org.at === "failed") {
+			const retry = org.retryable ? org.orgId === null ? (options) => auth.createOrganization(submission, options) : auth.retry : void 0;
+			return slots.organizationFailure({
+				state,
+				org,
+				...retry === void 0 ? {} : { retry }
+			});
+		}
+		if (org.at !== "ready") return slots.organizationProgress({
+			state,
+			org
+		});
+	}
+	if (state.account.at === "failed") return slots.accountFailure({
+		state,
+		account: state.account,
+		...state.account.retryable ? { retry: auth.retry } : {}
+	});
+	if (state.account.at !== "claimed") return slots.accountProgress({
+		state,
+		account: state.account
+	});
+	return ready(destination) ? slots.ready({
+		state,
+		destination
+	}) : null;
+}
+function organizationForm(props, state, auth, submitted) {
+	const profileDetails = submitted?.profileDetails ?? props.organizationProfile;
+	if (profileDetails === null) return null;
+	return props.slots.organization({
+		state,
+		profileDetails,
+		submitted,
+		pinnedHandle: submitted?.organization.handle ?? null,
+		submit: (organization, options) => {
+			if (submitted !== null) return auth.createOrganization(submitted, options);
+			const normalized = normalizeOrganization(organization);
+			if (normalized === null) return Promise.resolve({
+				ok: false,
+				reason: "INVALID_INPUT"
+			});
+			const next = {
+				profileDetails,
+				organization: normalized
+			};
+			props.onSubmittedOrganization(next);
+			return auth.createOrganization(next, options);
+		},
+		back: () => {
+			props.onOrganizationProfile(null);
+			props.navigation.organizationBack();
+		},
+		cancel: props.navigation.organizationCancel
+	});
+}
+//#endregion
+export { useCapxulAuth as a, useCapxulIdentityOrNull as c, capxulKeys as d, useCapxulClientOrNull as f, entered as i, useCapxulSend as l, CapxulOnboardingController as n, useCapxulDestination as o, useCapxul as p, CapxulProvider as r, useCapxulIdentity as s, CapxulAuthenticationController as t, useCapxulTransitions as u };
+
+//# sourceMappingURL=controllers-BU11km12.mjs.map