@hexclave/js 1.0.0 → 1.0.2

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

@@ -1,11 +1,11 @@
 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 = require("@hexclave/shared");
-let _stackframe_stack_shared_dist_utils_results = require("@hexclave/shared/dist/utils/results");
+let _hexclave_shared_dist_utils_errors = require("@hexclave/shared/dist/utils/errors");
+let _hexclave_shared = require("@hexclave/shared");
+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");
@@ -144,9 +144,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;
 				}
 			},
@@ -163,7 +163,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)(),
@@ -179,7 +179,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,
@@ -204,7 +204,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({
@@ -242,14 +242,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 || ""
@@ -267,7 +267,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;
 		});
@@ -377,7 +377,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,
@@ -385,9 +385,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);
 			}
 		};
 	}
@@ -397,11 +397,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,
@@ -497,20 +497,20 @@ var _StackServerAppImplIncomplete = class extends __client_app_impl_js._StackCli
 			},
 			getConnectedAccount,
 			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"));
 			},
 			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.");
 			},
 			selectedTeam: crud.selected_team ? app._serverTeamFromCrud(crud.selected_team) : null,
 			async getTeam(teamId) {
 				return (await this.listTeams()).find((t) => t.id === teamId) ?? null;
 			},
 			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,
@@ -539,20 +539,20 @@ 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));
 			},
 			async listPermissions(scopeOrOptions, options) {
 				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));
 				}
 			},
 			async getPermission(scopeOrPermissionId, permissionId) {
@@ -590,11 +590,11 @@ 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);
 			},
 			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));
 			},
 			createContactChannel: async (data) => {
 				const contactChannel = await app._interface.createServerContactChannel((0, ______contact_channels_index_js.serverContactChannelCreateOptionsToCrud)(crud.id, data));
@@ -602,10 +602,10 @@ var _StackServerAppImplIncomplete = class extends __client_app_impl_js._StackCli
 				return app._serverContactChannelFromCrud(crud.id, contactChannel);
 			},
 			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));
 			},
 			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");
@@ -613,31 +613,31 @@ var _StackServerAppImplIncomplete = class extends __client_app_impl_js._StackCli
 				return app._serverApiKeyFromCrud(result);
 			},
 			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));
 			},
 			async getOAuthProvider(id) {
 				return (await this.listOAuthProviders()).find((p) => p.id === id) ?? null;
 			},
 			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
@@ -716,7 +716,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));
 			},
 			async addUser(userId) {
 				await app._interface.addServerUserToTeam({
@@ -741,10 +741,10 @@ 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));
 			},
 			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");
@@ -813,18 +813,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;
 	}
 	async _getUserByApiKey(apiKey) {
@@ -858,7 +858,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) {
@@ -873,7 +873,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]":
@@ -887,11 +887,11 @@ 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);
 	}
 	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,
@@ -925,19 +925,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
@@ -946,21 +946,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
@@ -999,7 +999,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,
@@ -1013,7 +1013,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
 		}));
@@ -1037,7 +1037,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
@@ -1053,7 +1053,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"));
 	}
 	async activateEmailCapacityBoost() {
 		await this._interface.activateEmailCapacityBoost();
@@ -1083,9 +1083,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;
 		}
 	}