@hexclave/next 1.0.0 → 1.0.1

package/dist/lib/stack-app/apps/implementations/server-app-impl.js

@@ -1,14 +1,14 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_chunk = require('../../../../chunk-BE-pF4vm.js');
-let _stackframe_stack_shared_dist_utils_errors = require("@hexclave/shared/dist/utils/errors");
-let _stackframe_stack_shared_dist_utils_promises = require("@hexclave/shared/dist/utils/promises");
+let _hexclave_shared_dist_utils_errors = require("@hexclave/shared/dist/utils/errors");
+let _hexclave_shared_dist_utils_promises = require("@hexclave/shared/dist/utils/promises");
 let react = require("react");
-let _stackframe_stack_shared = require("@hexclave/shared");
-let _stackframe_stack_shared_dist_utils_react = require("@hexclave/shared/dist/utils/react");
-let _stackframe_stack_shared_dist_utils_results = require("@hexclave/shared/dist/utils/results");
+let _hexclave_shared = require("@hexclave/shared");
+let _hexclave_shared_dist_utils_react = require("@hexclave/shared/dist/utils/react");
+let _hexclave_shared_dist_utils_results = require("@hexclave/shared/dist/utils/results");
 let __common_js = require("./common.js");
 let _simplewebauthn_browser = require("@simplewebauthn/browser");
-let _stackframe_stack_shared_dist_sessions = require("@hexclave/shared/dist/sessions");
+let _hexclave_shared_dist_sessions = require("@hexclave/shared/dist/sessions");
 let ____________utils_url_js = require("../../../../utils/url.js");
 let ______api_keys_index_js = require("../../api-keys/index.js");
 let ______contact_channels_index_js = require("../../contact-channels/index.js");
@@ -153,9 +153,9 @@ var _StackServerAppImplIncomplete = class extends __client_app_impl_js._StackCli
 						allow_connected_accounts: data.allowConnectedAccounts
 					});
 					await Promise.all([app._serverOAuthProvidersCache.refresh([crud.user_id]), app._serverUserConnectedAccountsCache.refresh([crud.user_id])]);
-					return _stackframe_stack_shared_dist_utils_results.Result.ok(void 0);
+					return _hexclave_shared_dist_utils_results.Result.ok(void 0);
 				} catch (error) {
-					if (_stackframe_stack_shared.KnownErrors.OAuthProviderAccountIdAlreadyUsedForSignIn.isInstance(error)) return _stackframe_stack_shared_dist_utils_results.Result.error(error);
+					if (_hexclave_shared.KnownErrors.OAuthProviderAccountIdAlreadyUsedForSignIn.isInstance(error)) return _hexclave_shared_dist_utils_results.Result.error(error);
 					throw error;
 				}
 			},
@@ -172,7 +172,7 @@ var _StackServerAppImplIncomplete = class extends __client_app_impl_js._StackCli
 			...extraOptions,
 			interface: extraOptions?.interface ?? (() => {
 				const apiUrls = (0, __common_js.resolveApiUrls)(resolvedOptions.baseUrl);
-				return new _stackframe_stack_shared.HexclaveServerInterface({
+				return new _hexclave_shared.HexclaveServerInterface({
 					getBaseUrl: () => apiUrls()[0],
 					getApiUrls: apiUrls,
 					projectId: resolvedOptions.projectId ?? (0, __common_js.getDefaultProjectId)(),
@@ -188,7 +188,7 @@ var _StackServerAppImplIncomplete = class extends __client_app_impl_js._StackCli
 			return await this._interface.getServerUserByToken(session);
 		});
 		this._serverUsersCache = (0, __common_js.createCache)(async ([cursor, limit, orderBy, desc, query, includeRestricted, includeAnonymous, onlyAnonymous, teamId]) => {
-			if (onlyAnonymous && !includeAnonymous) throw new _stackframe_stack_shared_dist_utils_errors.HexclaveAssertionError("onlyAnonymous=true requires includeAnonymous=true");
+			if (onlyAnonymous && !includeAnonymous) throw new _hexclave_shared_dist_utils_errors.HexclaveAssertionError("onlyAnonymous=true requires includeAnonymous=true");
 			if (onlyAnonymous) return await this._interface.listServerUsers({
 				cursor,
 				limit,
@@ -213,7 +213,7 @@ var _StackServerAppImplIncomplete = class extends __client_app_impl_js._StackCli
 		});
 		this._serverUserCache = (0, __common_js.createCache)(async ([userId]) => {
 			const user = await this._interface.getServerUserById(userId);
-			return _stackframe_stack_shared_dist_utils_results.Result.or(user, null);
+			return _hexclave_shared_dist_utils_results.Result.or(user, null);
 		});
 		this._serverTeamsCache = (0, __common_js.createCache)(async ([userId, orderBy, desc, cursor, limit, query]) => {
 			return await this._interface.listServerTeamsPaginated({
@@ -251,14 +251,14 @@ var _StackServerAppImplIncomplete = class extends __client_app_impl_js._StackCli
 			try {
 				return { accessToken: (await this._interface.createServerProviderAccessToken(userId, providerId, scope || "")).access_token };
 			} catch (err) {
-				if (!(_stackframe_stack_shared.KnownErrors.OAuthAccessTokenNotAvailable.isInstance(err) || _stackframe_stack_shared.KnownErrors.OAuthConnectionDoesNotHaveRequiredScope.isInstance(err) || _stackframe_stack_shared.KnownErrors.OAuthConnectionNotConnectedToUser.isInstance(err))) throw err;
+				if (!(_hexclave_shared.KnownErrors.OAuthAccessTokenNotAvailable.isInstance(err) || _hexclave_shared.KnownErrors.OAuthConnectionDoesNotHaveRequiredScope.isInstance(err) || _hexclave_shared.KnownErrors.OAuthConnectionNotConnectedToUser.isInstance(err))) throw err;
 			}
 			return null;
 		});
 		this._serverUserOAuthConnectionCache = (0, __common_js.createCache)(async ([userId, providerId, scope, redirect]) => {
 			return await this._getUserOAuthConnectionCacheFn({
-				getUser: async () => _stackframe_stack_shared_dist_utils_results.Result.orThrow(await this._serverUserCache.getOrWait([userId], "write-only")),
-				getOrWaitOAuthToken: async () => _stackframe_stack_shared_dist_utils_results.Result.orThrow(await this._serverUserOAuthConnectionAccessTokensCache.getOrWait([
+				getUser: async () => _hexclave_shared_dist_utils_results.Result.orThrow(await this._serverUserCache.getOrWait([userId], "write-only")),
+				getOrWaitOAuthToken: async () => _hexclave_shared_dist_utils_results.Result.orThrow(await this._serverUserOAuthConnectionAccessTokensCache.getOrWait([
 					userId,
 					providerId,
 					scope || ""
@@ -281,7 +281,7 @@ var _StackServerAppImplIncomplete = class extends __client_app_impl_js._StackCli
 			try {
 				return { accessToken: (await this._interface.createServerProviderAccessTokenByAccount(userId, providerId, providerAccountId, scope || "")).access_token };
 			} catch (err) {
-				if (!(_stackframe_stack_shared.KnownErrors.OAuthAccessTokenNotAvailable.isInstance(err) || _stackframe_stack_shared.KnownErrors.OAuthConnectionDoesNotHaveRequiredScope.isInstance(err) || _stackframe_stack_shared.KnownErrors.OAuthConnectionNotConnectedToUser.isInstance(err))) throw err;
+				if (!(_hexclave_shared.KnownErrors.OAuthAccessTokenNotAvailable.isInstance(err) || _hexclave_shared.KnownErrors.OAuthConnectionDoesNotHaveRequiredScope.isInstance(err) || _hexclave_shared.KnownErrors.OAuthConnectionNotConnectedToUser.isInstance(err))) throw err;
 			}
 			return null;
 		});
@@ -391,7 +391,7 @@ var _StackServerAppImplIncomplete = class extends __client_app_impl_js._StackCli
 			providerAccountId,
 			async getAccessToken(options) {
 				const scopeString = options?.scopes?.join(" ") ?? "";
-				const result = _stackframe_stack_shared_dist_utils_results.Result.orThrow(await app._serverUserOAuthConnectionAccessTokensByAccountCache.getOrWait([
+				const result = _hexclave_shared_dist_utils_results.Result.orThrow(await app._serverUserOAuthConnectionAccessTokensByAccountCache.getOrWait([
 					userId,
 					providerId,
 					providerAccountId,
@@ -399,9 +399,9 @@ var _StackServerAppImplIncomplete = class extends __client_app_impl_js._StackCli
 				], "write-only"));
 				if (!result) {
 					const scopeDetail = scopeString ? `The requested scopes [${scopeString}] are not available on the existing token.` : "The OAuth refresh token has likely been revoked or expired.";
-					return _stackframe_stack_shared_dist_utils_results.Result.error(new _stackframe_stack_shared.KnownErrors.OAuthAccessTokenNotAvailable(providerId, `${scopeDetail} The user needs to re-authorize by calling \`linkConnectedAccount\` or using \`getOrLinkConnectedAccount\`.`));
+					return _hexclave_shared_dist_utils_results.Result.error(new _hexclave_shared.KnownErrors.OAuthAccessTokenNotAvailable(providerId, `${scopeDetail} The user needs to re-authorize by calling \`linkConnectedAccount\` or using \`getOrLinkConnectedAccount\`.`));
 				}
-				return _stackframe_stack_shared_dist_utils_results.Result.ok(result);
+				return _hexclave_shared_dist_utils_results.Result.ok(result);
 			},
 			useAccessToken(options) {
 				const scopeString = options?.scopes?.join(" ") ?? "";
@@ -413,9 +413,9 @@ var _StackServerAppImplIncomplete = class extends __client_app_impl_js._StackCli
 				], "connection.useAccessToken()");
 				if (!result) {
 					const scopeDetail = scopeString ? `The requested scopes [${scopeString}] are not available on the existing token.` : "The OAuth refresh token has likely been revoked or expired.";
-					return _stackframe_stack_shared_dist_utils_results.Result.error(new _stackframe_stack_shared.KnownErrors.OAuthAccessTokenNotAvailable(providerId, `${scopeDetail} The user needs to re-authorize by calling \`linkConnectedAccount\` or using \`getOrLinkConnectedAccount\`.`));
+					return _hexclave_shared_dist_utils_results.Result.error(new _hexclave_shared.KnownErrors.OAuthAccessTokenNotAvailable(providerId, `${scopeDetail} The user needs to re-authorize by calling \`linkConnectedAccount\` or using \`getOrLinkConnectedAccount\`.`));
 				}
-				return _stackframe_stack_shared_dist_utils_results.Result.ok(result);
+				return _hexclave_shared_dist_utils_results.Result.ok(result);
 			}
 		};
 	}
@@ -425,11 +425,11 @@ var _StackServerAppImplIncomplete = class extends __client_app_impl_js._StackCli
 			const scopeString = options?.scopes?.join(" ") ?? "";
 			if (typeof idOrAccount === "object" && "provider" in idOrAccount && "providerAccountId" in idOrAccount) {
 				const { provider, providerAccountId } = idOrAccount;
-				const found = _stackframe_stack_shared_dist_utils_results.Result.orThrow(await app._serverUserConnectedAccountsCache.getOrWait([crud.id], "write-only")).find((a) => a.provider === provider && a.providerAccountId === providerAccountId);
+				const found = _hexclave_shared_dist_utils_results.Result.orThrow(await app._serverUserConnectedAccountsCache.getOrWait([crud.id], "write-only")).find((a) => a.provider === provider && a.providerAccountId === providerAccountId);
 				if (!found) return null;
 				return found;
 			}
-			return _stackframe_stack_shared_dist_utils_results.Result.orThrow(await app._serverUserOAuthConnectionCache.getOrWait([
+			return _hexclave_shared_dist_utils_results.Result.orThrow(await app._serverUserOAuthConnectionCache.getOrWait([
 				crud.id,
 				idOrAccount,
 				scopeString,
@@ -539,19 +539,19 @@ var _StackServerAppImplIncomplete = class extends __client_app_impl_js._StackCli
 			getConnectedAccount,
 			useConnectedAccount,
 			async listConnectedAccounts() {
-				return _stackframe_stack_shared_dist_utils_results.Result.orThrow(await app._serverUserConnectedAccountsCache.getOrWait([crud.id], "write-only"));
+				return _hexclave_shared_dist_utils_results.Result.orThrow(await app._serverUserConnectedAccountsCache.getOrWait([crud.id], "write-only"));
 			},
 			useConnectedAccounts() {
 				return (0, __common_js.useAsyncCache)(app._serverUserConnectedAccountsCache, [crud.id], "user.useConnectedAccounts()");
 			},
 			async linkConnectedAccount() {
-				throw new _stackframe_stack_shared_dist_utils_errors.HexclaveAssertionError("linkConnectedAccount is not available for server users. OAuth flows must be initiated on the client side.");
+				throw new _hexclave_shared_dist_utils_errors.HexclaveAssertionError("linkConnectedAccount is not available for server users. OAuth flows must be initiated on the client side.");
 			},
 			async getOrLinkConnectedAccount() {
-				throw new _stackframe_stack_shared_dist_utils_errors.HexclaveAssertionError("getOrLinkConnectedAccount is not available for server users. OAuth flows must be initiated on the client side.");
+				throw new _hexclave_shared_dist_utils_errors.HexclaveAssertionError("getOrLinkConnectedAccount is not available for server users. OAuth flows must be initiated on the client side.");
 			},
 			useOrLinkConnectedAccount() {
-				throw new _stackframe_stack_shared_dist_utils_errors.HexclaveAssertionError("useOrLinkConnectedAccount is not available for server users. OAuth flows must be initiated on the client side.");
+				throw new _hexclave_shared_dist_utils_errors.HexclaveAssertionError("useOrLinkConnectedAccount is not available for server users. OAuth flows must be initiated on the client side.");
 			},
 			selectedTeam: crud.selected_team ? app._serverTeamFromCrud(crud.selected_team) : null,
 			async getTeam(teamId) {
@@ -564,7 +564,7 @@ var _StackServerAppImplIncomplete = class extends __client_app_impl_js._StackCli
 				}, [teams, teamId]);
 			},
 			async listTeams(options) {
-				const result = _stackframe_stack_shared_dist_utils_results.Result.orThrow(await app._serverTeamsCache.getOrWait([
+				const result = _hexclave_shared_dist_utils_results.Result.orThrow(await app._serverTeamsCache.getOrWait([
 					crud.id,
 					options?.orderBy,
 					options?.desc,
@@ -608,7 +608,7 @@ var _StackServerAppImplIncomplete = class extends __client_app_impl_js._StackCli
 				await app._refreshTeamMembership(team.id, crud.id);
 			},
 			async listTeamInvitations() {
-				return _stackframe_stack_shared_dist_utils_results.Result.orThrow(await app._serverUserTeamInvitationsCache.getOrWait([crud.id], "write-only")).map((inv) => app._serverReceivedTeamInvitationFromCrud(crud.id, inv));
+				return _hexclave_shared_dist_utils_results.Result.orThrow(await app._serverUserTeamInvitationsCache.getOrWait([crud.id], "write-only")).map((inv) => app._serverReceivedTeamInvitationFromCrud(crud.id, inv));
 			},
 			useTeamInvitations() {
 				const invitations = (0, __common_js.useAsyncCache)(app._serverUserTeamInvitationsCache, [crud.id], "user.useTeamInvitations()");
@@ -618,14 +618,14 @@ var _StackServerAppImplIncomplete = class extends __client_app_impl_js._StackCli
 				if (scopeOrOptions && "id" in scopeOrOptions) {
 					const scope = scopeOrOptions;
 					const recursive = options?.recursive ?? true;
-					return _stackframe_stack_shared_dist_utils_results.Result.orThrow(await app._serverTeamUserPermissionsCache.getOrWait([
+					return _hexclave_shared_dist_utils_results.Result.orThrow(await app._serverTeamUserPermissionsCache.getOrWait([
 						scope.id,
 						crud.id,
 						recursive
 					], "write-only")).map((crud) => app._serverPermissionFromCrud(crud));
 				} else {
 					const recursive = scopeOrOptions?.recursive ?? true;
-					return _stackframe_stack_shared_dist_utils_results.Result.orThrow(await app._serverUserProjectPermissionsCache.getOrWait([crud.id, recursive], "write-only")).map((crud) => app._serverPermissionFromCrud(crud));
+					return _hexclave_shared_dist_utils_results.Result.orThrow(await app._serverUserProjectPermissionsCache.getOrWait([crud.id, recursive], "write-only")).map((crud) => app._serverPermissionFromCrud(crud));
 				}
 			},
 			usePermissions(scopeOrOptions, options) {
@@ -690,7 +690,7 @@ var _StackServerAppImplIncomplete = class extends __client_app_impl_js._StackCli
 				return result;
 			},
 			async getTeamProfile(team) {
-				const result = _stackframe_stack_shared_dist_utils_results.Result.orThrow(await app._serverUserTeamProfileCache.getOrWait([team.id, crud.id], "write-only"));
+				const result = _hexclave_shared_dist_utils_results.Result.orThrow(await app._serverUserTeamProfileCache.getOrWait([team.id, crud.id], "write-only"));
 				return app._serverEditableTeamProfileFromCrud(result);
 			},
 			useTeamProfile(team) {
@@ -698,7 +698,7 @@ var _StackServerAppImplIncomplete = class extends __client_app_impl_js._StackCli
 				return (0, react.useMemo)(() => app._serverEditableTeamProfileFromCrud(result), [result]);
 			},
 			async listContactChannels() {
-				return _stackframe_stack_shared_dist_utils_results.Result.orThrow(await app._serverContactChannelsCache.getOrWait([crud.id], "write-only")).map((data) => app._serverContactChannelFromCrud(crud.id, data));
+				return _hexclave_shared_dist_utils_results.Result.orThrow(await app._serverContactChannelsCache.getOrWait([crud.id], "write-only")).map((data) => app._serverContactChannelFromCrud(crud.id, data));
 			},
 			useContactChannels() {
 				const result = (0, __common_js.useAsyncCache)(app._serverContactChannelsCache, [crud.id], "user.useContactChannels()");
@@ -713,13 +713,13 @@ var _StackServerAppImplIncomplete = class extends __client_app_impl_js._StackCli
 				return (0, __common_js.useAsyncCache)(app._serverNotificationCategoriesCache, [crud.id], "user.useNotificationCategories()").map((category) => app._serverNotificationCategoryFromCrud(crud.id, category));
 			},
 			async listNotificationCategories() {
-				return _stackframe_stack_shared_dist_utils_results.Result.orThrow(await app._serverNotificationCategoriesCache.getOrWait([crud.id], "write-only")).map((category) => app._serverNotificationCategoryFromCrud(crud.id, category));
+				return _hexclave_shared_dist_utils_results.Result.orThrow(await app._serverNotificationCategoriesCache.getOrWait([crud.id], "write-only")).map((category) => app._serverNotificationCategoryFromCrud(crud.id, category));
 			},
 			useApiKeys() {
 				return (0, __common_js.useAsyncCache)(app._serverUserApiKeysCache, [crud.id], "user.useApiKeys()").map((apiKey) => app._serverApiKeyFromCrud(apiKey));
 			},
 			async listApiKeys() {
-				return _stackframe_stack_shared_dist_utils_results.Result.orThrow(await app._serverUserApiKeysCache.getOrWait([crud.id], "write-only")).map((apiKey) => app._serverApiKeyFromCrud(apiKey));
+				return _hexclave_shared_dist_utils_results.Result.orThrow(await app._serverUserApiKeysCache.getOrWait([crud.id], "write-only")).map((apiKey) => app._serverApiKeyFromCrud(apiKey));
 			},
 			async createApiKey(options) {
 				const result = await app._interface.createProjectApiKey(await (0, ______api_keys_index_js.apiKeyCreationOptionsToCrud)("user", crud.id, options), null, "server");
@@ -731,7 +731,7 @@ var _StackServerAppImplIncomplete = class extends __client_app_impl_js._StackCli
 				return (0, react.useMemo)(() => results.map((oauthCrud) => app._serverOAuthProviderFromCrud(oauthCrud)), [results]);
 			},
 			async listOAuthProviders() {
-				return _stackframe_stack_shared_dist_utils_results.Result.orThrow(await app._serverOAuthProvidersCache.getOrWait([crud.id], "write-only")).map((oauthCrud) => app._serverOAuthProviderFromCrud(oauthCrud));
+				return _hexclave_shared_dist_utils_results.Result.orThrow(await app._serverOAuthProvidersCache.getOrWait([crud.id], "write-only")).map((oauthCrud) => app._serverOAuthProviderFromCrud(oauthCrud));
 			},
 			useOAuthProvider(id) {
 				const providers = this.useOAuthProviders();
@@ -742,24 +742,24 @@ var _StackServerAppImplIncomplete = class extends __client_app_impl_js._StackCli
 			},
 			async registerPasskey(options) {
 				const hostname = options?.hostname || (await app._getCurrentUrl())?.hostname;
-				if (!hostname) throw new _stackframe_stack_shared_dist_utils_errors.HexclaveAssertionError("hostname must be provided if the Stack App does not have a redirect method");
+				if (!hostname) throw new _hexclave_shared_dist_utils_errors.HexclaveAssertionError("hostname must be provided if the Stack App does not have a redirect method");
 				const initiationResult = await app._interface.initiateServerPasskeyRegistration(crud.id);
-				if (initiationResult.status !== "ok") return _stackframe_stack_shared_dist_utils_results.Result.error(new _stackframe_stack_shared.KnownErrors.PasskeyRegistrationFailed("Failed to get initiation options for passkey registration"));
+				if (initiationResult.status !== "ok") return _hexclave_shared_dist_utils_results.Result.error(new _hexclave_shared.KnownErrors.PasskeyRegistrationFailed("Failed to get initiation options for passkey registration"));
 				const { options_json, code } = initiationResult.data;
-				if (options_json.rp.id !== "THIS_VALUE_WILL_BE_REPLACED.example.com") throw new _stackframe_stack_shared_dist_utils_errors.HexclaveAssertionError(`Expected returned RP ID from server to equal sentinel, but found ${options_json.rp.id}`);
+				if (options_json.rp.id !== "THIS_VALUE_WILL_BE_REPLACED.example.com") throw new _hexclave_shared_dist_utils_errors.HexclaveAssertionError(`Expected returned RP ID from server to equal sentinel, but found ${options_json.rp.id}`);
 				options_json.rp.id = hostname;
 				let attResp;
 				try {
 					attResp = await (0, _simplewebauthn_browser.startRegistration)({ optionsJSON: options_json });
 				} catch (error) {
-					if (error instanceof _simplewebauthn_browser.WebAuthnError) return _stackframe_stack_shared_dist_utils_results.Result.error(new _stackframe_stack_shared.KnownErrors.PasskeyWebAuthnError(error.message, error.name));
+					if (error instanceof _simplewebauthn_browser.WebAuthnError) return _hexclave_shared_dist_utils_results.Result.error(new _hexclave_shared.KnownErrors.PasskeyWebAuthnError(error.message, error.name));
 					else {
-						(0, _stackframe_stack_shared_dist_utils_errors.captureError)("passkey-registration-failed", error);
-						return _stackframe_stack_shared_dist_utils_results.Result.error(new _stackframe_stack_shared.KnownErrors.PasskeyRegistrationFailed("Failed to start passkey registration due to unknown error"));
+						(0, _hexclave_shared_dist_utils_errors.captureError)("passkey-registration-failed", error);
+						return _hexclave_shared_dist_utils_results.Result.error(new _hexclave_shared.KnownErrors.PasskeyRegistrationFailed("Failed to start passkey registration due to unknown error"));
 					}
 				}
 				const { accessToken, refreshToken } = await app._interface.createServerUserSession(crud.id, 6e4 * 2, false);
-				const tempSession = new _stackframe_stack_shared_dist_sessions.InternalSession({
+				const tempSession = new _hexclave_shared_dist_sessions.InternalSession({
 					accessToken,
 					refreshToken,
 					refreshAccessTokenCallback: async () => null
@@ -838,7 +838,7 @@ var _StackServerAppImplIncomplete = class extends __client_app_impl_js._StackCli
 				await Promise.all([app._serverTeamsCache.refreshWhere(() => true), app._serverUsersCache.refreshWhere(() => true)]);
 			},
 			async listUsers() {
-				return _stackframe_stack_shared_dist_utils_results.Result.orThrow(await app._serverTeamMemberProfilesCache.getOrWait([crud.id], "write-only")).map((u) => app._serverTeamUserFromCrud(u));
+				return _hexclave_shared_dist_utils_results.Result.orThrow(await app._serverTeamMemberProfilesCache.getOrWait([crud.id], "write-only")).map((u) => app._serverTeamUserFromCrud(u));
 			},
 			useUsers() {
 				const result = (0, __common_js.useAsyncCache)(app._serverTeamMemberProfilesCache, [crud.id], "team.useUsers()");
@@ -867,7 +867,7 @@ var _StackServerAppImplIncomplete = class extends __client_app_impl_js._StackCli
 				await app._serverTeamInvitationsCache.refresh([crud.id]);
 			},
 			async listInvitations() {
-				return _stackframe_stack_shared_dist_utils_results.Result.orThrow(await app._serverTeamInvitationsCache.getOrWait([crud.id], "write-only")).map((crud) => app._serverSentTeamInvitationFromCrud(crud));
+				return _hexclave_shared_dist_utils_results.Result.orThrow(await app._serverTeamInvitationsCache.getOrWait([crud.id], "write-only")).map((crud) => app._serverSentTeamInvitationFromCrud(crud));
 			},
 			useInvitations() {
 				const result = (0, __common_js.useAsyncCache)(app._serverTeamInvitationsCache, [crud.id], "team.useInvitations()");
@@ -877,7 +877,7 @@ var _StackServerAppImplIncomplete = class extends __client_app_impl_js._StackCli
 				return (0, __common_js.useAsyncCache)(app._serverTeamApiKeysCache, [crud.id], "team.useApiKeys()").map((apiKey) => app._serverApiKeyFromCrud(apiKey));
 			},
 			async listApiKeys() {
-				return _stackframe_stack_shared_dist_utils_results.Result.orThrow(await app._serverTeamApiKeysCache.getOrWait([crud.id], "write-only")).map((apiKey) => app._serverApiKeyFromCrud(apiKey));
+				return _hexclave_shared_dist_utils_results.Result.orThrow(await app._serverTeamApiKeysCache.getOrWait([crud.id], "write-only")).map((apiKey) => app._serverApiKeyFromCrud(apiKey));
 			},
 			async createApiKey(options) {
 				const result = await app._interface.createProjectApiKey(await (0, ______api_keys_index_js.apiKeyCreationOptionsToCrud)("team", crud.id, options), null, "server");
@@ -946,18 +946,18 @@ var _StackServerAppImplIncomplete = class extends __client_app_impl_js._StackCli
 					else await app._serverCustomItemsCache.refresh([customer.id, crud.id]);
 					return true;
 				} catch (error) {
-					if (error instanceof _stackframe_stack_shared.KnownErrors.ItemQuantityInsufficientAmount) return false;
+					if (error instanceof _hexclave_shared.KnownErrors.ItemQuantityInsufficientAmount) return false;
 					throw error;
 				}
 			}
 		};
 	}
 	async _getUserApiKey(options) {
-		const crud = _stackframe_stack_shared_dist_utils_results.Result.orThrow(await this._serverCheckApiKeyCache.getOrWait(["user", options.apiKey], "write-only"));
+		const crud = _hexclave_shared_dist_utils_results.Result.orThrow(await this._serverCheckApiKeyCache.getOrWait(["user", options.apiKey], "write-only"));
 		return crud ? this._serverApiKeyFromCrud(crud) : null;
 	}
 	async _getTeamApiKey(options) {
-		const crud = _stackframe_stack_shared_dist_utils_results.Result.orThrow(await this._serverCheckApiKeyCache.getOrWait(["team", options.apiKey], "write-only"));
+		const crud = _hexclave_shared_dist_utils_results.Result.orThrow(await this._serverCheckApiKeyCache.getOrWait(["team", options.apiKey], "write-only"));
 		return crud ? this._serverApiKeyFromCrud(crud) : null;
 	}
 	_useUserApiKey(options) {
@@ -1016,7 +1016,7 @@ var _StackServerAppImplIncomplete = class extends __client_app_impl_js._StackCli
 			if (options?.or === "anonymous" && options.includeRestricted === false) throw new Error("Cannot use { or: 'anonymous' } with { includeRestricted: false }. Anonymous users implicitly include restricted users.");
 			this._ensurePersistentTokenStore(options?.tokenStore);
 			const session = await this._getSession(options?.tokenStore);
-			let crud = _stackframe_stack_shared_dist_utils_results.Result.orThrow(await this._currentServerUserCache.getOrWait([session], "write-only"));
+			let crud = _hexclave_shared_dist_utils_results.Result.orThrow(await this._currentServerUserCache.getOrWait([session], "write-only"));
 			const includeAnonymous = options?.or === "anonymous" || options?.or === "anonymous-if-exists[deprecated]";
 			const includeRestricted = options?.includeRestricted === true || includeAnonymous;
 			if (crud === null || crud.is_anonymous && !includeAnonymous || crud.is_restricted && !includeRestricted) switch (options?.or) {
@@ -1031,7 +1031,7 @@ var _StackServerAppImplIncomplete = class extends __client_app_impl_js._StackCli
 						tokenStore: tokens,
 						or: "anonymous-if-exists[deprecated]",
 						includeRestricted: true
-					}) ?? (0, _stackframe_stack_shared_dist_utils_errors.throwErr)("Something went wrong while signing up anonymously");
+					}) ?? (0, _hexclave_shared_dist_utils_errors.throwErr)("Something went wrong while signing up anonymously");
 				}
 				case void 0:
 				case "anonymous-if-exists[deprecated]":
@@ -1045,7 +1045,7 @@ var _StackServerAppImplIncomplete = class extends __client_app_impl_js._StackCli
 		return await this.getUser();
 	}
 	async getServerUserById(userId) {
-		const crud = _stackframe_stack_shared_dist_utils_results.Result.orThrow(await this._serverUserCache.getOrWait([userId], "write-only"));
+		const crud = _hexclave_shared_dist_utils_results.Result.orThrow(await this._serverUserCache.getOrWait([userId], "write-only"));
 		return crud && this._serverUserFromCrud(crud);
 	}
 	useUser(options) {
@@ -1062,17 +1062,17 @@ var _StackServerAppImplIncomplete = class extends __client_app_impl_js._StackCli
 			options?.includeRestricted;
 			if (crud === null) switch (options?.or) {
 				case "redirect":
-					(0, _stackframe_stack_shared_dist_utils_promises.runAsynchronously)(this.redirectToSignIn({ replace: true }));
-					(0, _stackframe_stack_shared_dist_utils_react.suspend)();
-					throw new _stackframe_stack_shared_dist_utils_errors.HexclaveAssertionError("suspend should never return");
+					(0, _hexclave_shared_dist_utils_promises.runAsynchronously)(this.redirectToSignIn({ replace: true }));
+					(0, _hexclave_shared_dist_utils_react.suspend)();
+					throw new _hexclave_shared_dist_utils_errors.HexclaveAssertionError("suspend should never return");
 				case "throw": throw new Error("User is not signed in but useUser was called with { or: 'throw' }");
 				case "anonymous":
-					(0, _stackframe_stack_shared_dist_utils_promises.runAsynchronously)(async () => {
+					(0, _hexclave_shared_dist_utils_promises.runAsynchronously)(async () => {
 						await this._signUpAnonymously();
 						if (typeof window !== "undefined") window.location.reload();
 					});
-					(0, _stackframe_stack_shared_dist_utils_react.suspend)();
-					throw new _stackframe_stack_shared_dist_utils_errors.HexclaveAssertionError("suspend should never return");
+					(0, _hexclave_shared_dist_utils_react.suspend)();
+					throw new _hexclave_shared_dist_utils_errors.HexclaveAssertionError("suspend should never return");
 				case void 0:
 				case "anonymous-if-exists[deprecated]":
 				case "return-null":
@@ -1093,7 +1093,7 @@ var _StackServerAppImplIncomplete = class extends __client_app_impl_js._StackCli
 		}, [crud]);
 	}
 	async listUsers(options) {
-		const crud = _stackframe_stack_shared_dist_utils_results.Result.orThrow(await this._serverUsersCache.getOrWait([
+		const crud = _hexclave_shared_dist_utils_results.Result.orThrow(await this._serverUsersCache.getOrWait([
 			options?.cursor,
 			options?.limit,
 			options?.orderBy,
@@ -1143,19 +1143,19 @@ var _StackServerAppImplIncomplete = class extends __client_app_impl_js._StackCli
 	}
 	async getItem(options) {
 		if ("userId" in options) {
-			const result = _stackframe_stack_shared_dist_utils_results.Result.orThrow(await this._serverUserItemsCache.getOrWait([options.userId, options.itemId], "write-only"));
+			const result = _hexclave_shared_dist_utils_results.Result.orThrow(await this._serverUserItemsCache.getOrWait([options.userId, options.itemId], "write-only"));
 			return this._serverItemFromCrud({
 				type: "user",
 				id: options.userId
 			}, result);
 		} else if ("teamId" in options) {
-			const result = _stackframe_stack_shared_dist_utils_results.Result.orThrow(await this._serverTeamItemsCache.getOrWait([options.teamId, options.itemId], "write-only"));
+			const result = _hexclave_shared_dist_utils_results.Result.orThrow(await this._serverTeamItemsCache.getOrWait([options.teamId, options.itemId], "write-only"));
 			return this._serverItemFromCrud({
 				type: "team",
 				id: options.teamId
 			}, result);
 		} else {
-			const result = _stackframe_stack_shared_dist_utils_results.Result.orThrow(await this._serverCustomItemsCache.getOrWait([options.customCustomerId, options.itemId], "write-only"));
+			const result = _hexclave_shared_dist_utils_results.Result.orThrow(await this._serverCustomItemsCache.getOrWait([options.customCustomerId, options.itemId], "write-only"));
 			return this._serverItemFromCrud({
 				type: "custom",
 				id: options.customCustomerId
@@ -1164,21 +1164,21 @@ var _StackServerAppImplIncomplete = class extends __client_app_impl_js._StackCli
 	}
 	async listProducts(options) {
 		if ("userId" in options) {
-			const response = _stackframe_stack_shared_dist_utils_results.Result.orThrow(await this._serverUserProductsCache.getOrWait([
+			const response = _hexclave_shared_dist_utils_results.Result.orThrow(await this._serverUserProductsCache.getOrWait([
 				options.userId,
 				options.cursor ?? null,
 				options.limit ?? null
 			], "write-only"));
 			return this._customerProductsFromResponse(response);
 		} else if ("teamId" in options) {
-			const response = _stackframe_stack_shared_dist_utils_results.Result.orThrow(await this._serverTeamProductsCache.getOrWait([
+			const response = _hexclave_shared_dist_utils_results.Result.orThrow(await this._serverTeamProductsCache.getOrWait([
 				options.teamId,
 				options.cursor ?? null,
 				options.limit ?? null
 			], "write-only"));
 			return this._customerProductsFromResponse(response);
 		}
-		const response = _stackframe_stack_shared_dist_utils_results.Result.orThrow(await this._serverCustomProductsCache.getOrWait([
+		const response = _hexclave_shared_dist_utils_results.Result.orThrow(await this._serverCustomProductsCache.getOrWait([
 			options.customCustomerId,
 			options.cursor ?? null,
 			options.limit ?? null
@@ -1241,7 +1241,7 @@ var _StackServerAppImplIncomplete = class extends __client_app_impl_js._StackCli
 		return this._serverTeamFromCrud(team);
 	}
 	async listTeams(options) {
-		const crud = _stackframe_stack_shared_dist_utils_results.Result.orThrow(await this._serverTeamsCache.getOrWait([
+		const crud = _hexclave_shared_dist_utils_results.Result.orThrow(await this._serverTeamsCache.getOrWait([
 			void 0,
 			options?.orderBy,
 			options?.desc,
@@ -1270,7 +1270,7 @@ var _StackServerAppImplIncomplete = class extends __client_app_impl_js._StackCli
 	}
 	async listTeamMemberPermissions(teamId, options) {
 		const recursive = options?.recursive ?? false;
-		return _stackframe_stack_shared_dist_utils_results.Result.orThrow(await this._serverAllTeamMemberPermissionsCache.getOrWait([teamId, recursive], "write-only")).map((r) => ({
+		return _hexclave_shared_dist_utils_results.Result.orThrow(await this._serverAllTeamMemberPermissionsCache.getOrWait([teamId, recursive], "write-only")).map((r) => ({
 			userId: r.user_id,
 			permissionId: r.id
 		}));
@@ -1312,7 +1312,7 @@ var _StackServerAppImplIncomplete = class extends __client_app_impl_js._StackCli
 			},
 			getValue: async (key, options) => {
 				validateOptions(options);
-				return _stackframe_stack_shared_dist_utils_results.Result.orThrow(await this._serverDataVaultStoreValueCache.getOrWait([
+				return _hexclave_shared_dist_utils_results.Result.orThrow(await this._serverDataVaultStoreValueCache.getOrWait([
 					id,
 					key,
 					options.secret
@@ -1339,7 +1339,7 @@ var _StackServerAppImplIncomplete = class extends __client_app_impl_js._StackCli
 		await this._emailDeliveryInfoCache.refresh([]);
 	}
 	async getEmailDeliveryStats() {
-		return _stackframe_stack_shared_dist_utils_results.Result.orThrow(await this._emailDeliveryInfoCache.getOrWait([], "write-only"));
+		return _hexclave_shared_dist_utils_results.Result.orThrow(await this._emailDeliveryInfoCache.getOrWait([], "write-only"));
 	}
 	useEmailDeliveryStats() {
 		return (0, __common_js.useAsyncCache)(this._emailDeliveryInfoCache, [], "stackServerApp.useEmailDeliveryStats()");
@@ -1372,9 +1372,9 @@ var _StackServerAppImplIncomplete = class extends __client_app_impl_js._StackCli
 				allow_connected_accounts: options.allowConnectedAccounts
 			});
 			await Promise.all([this._serverOAuthProvidersCache.refresh([options.userId]), this._serverUserConnectedAccountsCache.refresh([options.userId])]);
-			return _stackframe_stack_shared_dist_utils_results.Result.ok(this._serverOAuthProviderFromCrud(crud));
+			return _hexclave_shared_dist_utils_results.Result.ok(this._serverOAuthProviderFromCrud(crud));
 		} catch (error) {
-			if (_stackframe_stack_shared.KnownErrors.OAuthProviderAccountIdAlreadyUsedForSignIn.isInstance(error)) return _stackframe_stack_shared_dist_utils_results.Result.error(error);
+			if (_hexclave_shared.KnownErrors.OAuthProviderAccountIdAlreadyUsedForSignIn.isInstance(error)) return _hexclave_shared_dist_utils_results.Result.error(error);
 			throw error;
 		}
 	}