@stackframe/stack-shared 2.5.2 → 2.5.4

package/dist/schema-fields.js

@@ -1,11 +1,63 @@
 import * as yup from "yup";
-import { yupJson } from "./utils/yup";
+const _idDescription = (identify) => `The immutable ID used to uniquely identify this ${identify}`;
+const _displayNameDescription = (identify) => `Human-readable ${identify} display name, used in places like frontend UI. This is not a unique identifier.`;
+const _clientMetaDataDescription = (identify) => `Client metadata. Used as a data store, accessible from the client side. Do not store information that should not be exposed to the client.`;
+const _serverMetaDataDescription = (identify) => `Server metadata. Used as a data store, only accessible from the server side. You can store secret information related to the ${identify} here.`;
+const _atMillisDescription = (identify) => `(the number of milliseconds since epoch, January 1, 1970, UTC)`;
+const _createdAtMillisDescription = (identify) => `The time the ${identify} was created ${_atMillisDescription(identify)}`;
+const _updatedAtMillisDescription = (identify) => `The time the ${identify} was last updated ${_atMillisDescription(identify)}`;
+// Built-in replacements
+/* eslint-disable no-restricted-syntax */
+export function yupString(...args) {
+    return yup.string(...args);
+}
+export function yupNumber(...args) {
+    return yup.number(...args);
+}
+export function yupBoolean(...args) {
+    return yup.boolean(...args);
+}
+/**
+ * @deprecated, use number of milliseconds since epoch instead
+ */
+export function yupDate(...args) {
+    return yup.date(...args);
+}
+export function yupMixed(...args) {
+    return yup.mixed(...args);
+}
+export function yupArray(...args) {
+    return yup.array(...args);
+}
+export function yupTuple(...args) {
+    return yup.tuple(...args);
+}
+export function yupObject(...args) {
+    const object = yup.object(...args).test('no-unknown-object-properties', ({ path }) => `${path} contains unknown properties`, (value, context) => {
+        if (context.options.context?.noUnknownPathPrefixes?.some((prefix) => context.path.startsWith(prefix))) {
+            const availableKeys = new Set(Object.keys(context.schema.fields));
+            const unknownKeys = Object.keys(value ?? {}).filter(key => !availableKeys.has(key));
+            if (unknownKeys.length > 0) {
+                // TODO "did you mean XYZ"
+                return context.createError({
+                    message: `${context.path} contains unknown properties: ${unknownKeys.join(', ')}`,
+                    path: context.path,
+                    params: { unknownKeys },
+                });
+            }
+        }
+        return true;
+    });
+    // we don't want to update the type of `object` to have a default flag
+    return object.default(undefined);
+}
+/* eslint-enable no-restricted-syntax */
 // Common
-export const adaptSchema = yup.mixed();
+export const adaptSchema = yupMixed();
 /**
  * Yup's URL schema does not recognize some URLs (including `http://localhost`) as a valid URL. This schema is a workaround for that.
  */
-export const urlSchema = yup.string().test({
+export const urlSchema = yupString().test({
     name: 'url',
     message: 'Invalid URL',
     test: (value) => {
@@ -20,23 +72,62 @@ export const urlSchema = yup.string().test({
         }
     },
 });
+export const jsonSchema = yupMixed().nullable().defined().transform((value) => JSON.parse(JSON.stringify(value)));
+export const jsonStringSchema = yupString().test("json", "Invalid JSON format", (value) => {
+    if (value == null)
+        return true;
+    try {
+        JSON.parse(value);
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+});
+export const emailSchema = yupString().email();
 // Request auth
-export const clientOrHigherAuthTypeSchema = yup.string().oneOf(['client', 'server', 'admin']);
-export const serverOrHigherAuthTypeSchema = yup.string().oneOf(['server', 'admin']);
-export const adminAuthTypeSchema = yup.string().oneOf(['admin']);
+export const clientOrHigherAuthTypeSchema = yupString().oneOf(['client', 'server', 'admin']);
+export const serverOrHigherAuthTypeSchema = yupString().oneOf(['server', 'admin']);
+export const adminAuthTypeSchema = yupString().oneOf(['admin']);
 // Projects
-export const projectIdSchema = yup.string().meta({ openapiField: { description: 'Project ID as retrieved on Stack\'s dashboard', exampleValue: 'project-id' } });
+export const projectIdSchema = yupString().meta({ openapiField: { description: _idDescription('project'), exampleValue: 'e0b52f4d-dece-408c-af49-d23061bb0f8d' } });
+export const projectDisplayNameSchema = yupString().meta({ openapiField: { description: _displayNameDescription('project'), exampleValue: 'MyMusic' } });
+export const projectDescriptionSchema = yupString().nullable().meta({ openapiField: { description: 'A human readable description of the project', exampleValue: 'A music streaming service' } });
+export const projectCreatedAtMillisSchema = yupNumber().meta({ openapiField: { description: _createdAtMillisDescription('project'), exampleValue: 1630000000000 } });
+export const projectUserCountSchema = yupNumber().meta({ openapiField: { description: 'The number of users in this project', exampleValue: 10 } });
+export const projectIsProductionModeSchema = yupBoolean().meta({ openapiField: { description: 'Whether the project is in production mode', exampleValue: true } });
+// Project config
+export const projectConfigIdSchema = yupString().meta({ openapiField: { description: _idDescription('project config'), exampleValue: 'd09201f0-54f5-40bd-89ff-6d1815ddad24' } });
+export const projectAllowLocalhostSchema = yupBoolean().meta({ openapiField: { description: 'Whether localhost is allowed as a domain for this project. Should only be allowed in development mode', exampleValue: true } });
+export const projectCreateTeamOnSignUpSchema = yupBoolean().meta({ openapiField: { description: 'Whether a team should be created for each user that signs up', exampleValue: true } });
+export const projectMagicLinkEnabledSchema = yupBoolean().meta({ openapiField: { description: 'Whether magic link authentication is enabled for this project', exampleValue: true } });
+export const projectCredentialEnabledSchema = yupBoolean().meta({ openapiField: { description: 'Whether email password authentication is enabled for this project', exampleValue: true } });
+// Project OAuth config
+export const oauthIdSchema = yupString().oneOf(['google', 'github', 'facebook', 'microsoft', 'spotify']).meta({ openapiField: { description: 'OAuth provider ID, one of google, github, facebook, microsoft, spotify', exampleValue: 'google' } });
+export const oauthEnabledSchema = yupBoolean().meta({ openapiField: { description: 'Whether the OAuth provider is enabled. If an provider is first enabled, then disabled, it will be shown in the list but with enabled=false', exampleValue: true } });
+export const oauthTypeSchema = yupString().oneOf(['shared', 'standard']).meta({ openapiField: { description: 'OAuth provider type, one of shared, standard. "shared" uses Stack shared OAuth keys and it is only meant for development. "standard" uses your own OAuth keys and will show your logo and company name when signing in with the provider.', exampleValue: 'standard' } });
+export const oauthClientIdSchema = yupString().meta({ openapiField: { description: 'OAuth client ID. Needs to be specified when using type="standard"', exampleValue: 'google-oauth-client-id' } });
+export const oauthClientSecretSchema = yupString().meta({ openapiField: { description: 'OAuth client secret. Needs to be specified when using type="standard"', exampleValue: 'google-oauth-client-secret' } });
+// Project email config
+export const emailTypeSchema = yupString().oneOf(['shared', 'standard']).meta({ openapiField: { description: 'Email provider type, one of shared, standard. "shared" uses Stack shared email provider and it is only meant for development. "standard" uses your own email server and will have your email address as the sender.', exampleValue: 'standard' } });
+export const emailSenderNameSchema = yupString().meta({ openapiField: { description: 'Email sender name. Needs to be specified when using type="standard"', exampleValue: 'Stack' } });
+export const emailHostSchema = yupString().meta({ openapiField: { description: 'Email host. Needs to be specified when using type="standard"', exampleValue: 'smtp.your-domain.com' } });
+export const emailPortSchema = yupNumber().meta({ openapiField: { description: 'Email port. Needs to be specified when using type="standard"', exampleValue: 587 } });
+export const emailUsernameSchema = yupString().meta({ openapiField: { description: 'Email username. Needs to be specified when using type="standard"', exampleValue: 'smtp-email' } });
+export const emailSenderEmailSchema = emailSchema.meta({ openapiField: { description: 'Email sender email. Needs to be specified when using type="standard"', exampleValue: 'example@your-domain.com' } });
+export const emailPasswordSchema = yupString().meta({ openapiField: { description: 'Email password. Needs to be specified when using type="standard"', exampleValue: 'your-email-password' } });
+// Project domain config
+export const domainSchema = yupString().test('is-https', 'Domain must start with https://', (value) => value?.startsWith('https://')).meta({ openapiField: { description: 'Your domain URL. Make sure you own and trust this domain. Needs to start with https://', exampleValue: 'example.com' } });
+export const handlerPathSchema = yupString().test('is-handler-path', 'Handler path must start with /', (value) => value?.startsWith('/')).meta({ openapiField: { description: 'Handler path. If you did not setup a custom handler path, it should be "/handler" by default. It needs to start with /', exampleValue: '/handler' } });
 // Users
-export const userIdRequestSchema = yup.string().uuid().meta({ openapiField: { description: 'The ID of the user', exampleValue: '3241a285-8329-4d69-8f3d-316e08cf140c' } });
 export class ReplaceFieldWithOwnUserId extends Error {
-    path;
     constructor(path) {
         super(`This error should be caught by whoever validated the schema, and the field in the path '${path}' should be replaced with the current user's id. This is a workaround to yup not providing access to the context inside the transform function.`);
         this.path = path;
     }
 }
 const userIdMeSentinelUuid = "cad564fd-f81b-43f4-b390-98abf3fcc17e";
-export const userIdOrMeRequestSchema = yup.string().uuid().transform(v => {
+export const userIdOrMeSchema = yupString().uuid().transform(v => {
     if (v === "me")
         return userIdMeSentinelUuid;
     else
@@ -46,23 +137,62 @@ export const userIdOrMeRequestSchema = yup.string().uuid().transform(v => {
         throw new ReplaceFieldWithOwnUserId(context.path);
     return true;
 }).meta({ openapiField: { description: 'The ID of the user, or the special value `me` to signify the currently authenticated user', exampleValue: '3241a285-8329-4d69-8f3d-316e08cf140c' } });
-export const userIdResponseSchema = yup.string().uuid().meta({ openapiField: { description: 'The immutable user ID used to uniquely identify this user', exampleValue: '3241a285-8329-4d69-8f3d-316e08cf140c' } });
-export const primaryEmailSchema = yup.string().email().meta({ openapiField: { description: 'Primary email', exampleValue: 'johndoe@example.com' } });
-export const primaryEmailVerifiedSchema = yup.boolean().meta({ openapiField: { description: 'Whether the primary email has been verified to belong to this user', exampleValue: true } });
-export const userDisplayNameSchema = yup.string().nullable().meta({ openapiField: { description: 'Human-readable display name', exampleValue: 'John Doe' } });
-export const selectedTeamIdSchema = yup.string().meta({ openapiField: { description: 'ID of the team currently selected by the user', exampleValue: 'team-id' } });
-export const profileImageUrlSchema = yup.string().meta({ openapiField: { description: 'Profile image URL', exampleValue: 'https://example.com/image.jpg' } });
-export const signedUpAtMillisSchema = yup.number().meta({ openapiField: { description: 'Signed up at milliseconds', exampleValue: 1630000000000 } });
-export const userClientMetadataSchema = yupJson.meta({ openapiField: { description: 'Client metadata. Used as a data store, accessible from the client side', exampleValue: { key: 'value' } } });
-export const userServerMetadataSchema = yupJson.meta({ openapiField: { description: 'Server metadata. Used as a data store, only accessible from the server side', exampleValue: { key: 'value' } } });
+export const userIdSchema = yupString().uuid().meta({ openapiField: { description: _idDescription('user'), exampleValue: '3241a285-8329-4d69-8f3d-316e08cf140c' } });
+export const primaryEmailSchema = emailSchema.meta({ openapiField: { description: 'Primary email', exampleValue: 'johndoe@example.com' } });
+export const primaryEmailVerifiedSchema = yupBoolean().meta({ openapiField: { description: 'Whether the primary email has been verified to belong to this user', exampleValue: true } });
+export const userDisplayNameSchema = yupString().nullable().meta({ openapiField: { description: _displayNameDescription('user'), exampleValue: 'John Doe' } });
+export const selectedTeamIdSchema = yupString().meta({ openapiField: { description: 'ID of the team currently selected by the user', exampleValue: 'team-id' } });
+export const profileImageUrlSchema = yupString().meta({ openapiField: { description: 'Profile image URL', exampleValue: 'https://example.com/image.jpg' } });
+export const signedUpAtMillisSchema = yupNumber().meta({ openapiField: { description: 'Signed up at milliseconds', exampleValue: 1630000000000 } });
+export const userClientMetadataSchema = jsonSchema.meta({ openapiField: { description: _clientMetaDataDescription('user'), exampleValue: { key: 'value' } } });
+export const userServerMetadataSchema = jsonSchema.meta({ openapiField: { description: _serverMetaDataDescription('user'), exampleValue: { key: 'value' } } });
 // Auth
-export const signInEmailSchema = yup.string().email().meta({ openapiField: { description: 'The email to sign in with.', exampleValue: 'johndoe@example.com' } });
-export const verificationLinkRedirectUrlSchema = urlSchema.meta({ openapiField: { description: 'The URL to redirect to after the user has verified their email. A query argument `code` with the verification code will be appended to it.', exampleValue: 'https://example.com/handler' } });
-export const accessTokenResponseSchema = yup.string().meta({ openapiField: { description: 'Short-lived access token that can be used to authenticate the user', exampleValue: 'eyJhmMiJBMTO...diI4QT' } });
-export const refreshTokenResponseSchema = yup.string().meta({ openapiField: { description: 'Long-lived refresh token that can be used to obtain a new access token', exampleValue: 'i8nsoaq2...14y' } });
-export const signInResponseSchema = yup.object({
+export const signInEmailSchema = emailSchema.meta({ openapiField: { description: 'The email to sign in with.', exampleValue: 'johndoe@example.com' } });
+export const emailOtpSignInCallbackUrlSchema = urlSchema.meta({ openapiField: { description: 'The base callback URL to construct the magic link from. A query argument `code` with the verification code will be appended to it. The page should then make a request to the `/auth/otp/sign-in` endpoint.', exampleValue: 'https://example.com/handler/magic-link-callback' } });
+export const emailVerificationCallbackUrlSchema = urlSchema.meta({ openapiField: { description: 'The base callback URL to construct a verification link for the verification e-mail. A query argument `code` with the verification code will be appended to it. The page should then make a request to the `/contact-channels/verify` endpoint.', exampleValue: 'https://example.com/handler/email-verification' } });
+export const accessTokenResponseSchema = yupString().meta({ openapiField: { description: 'Short-lived access token that can be used to authenticate the user', exampleValue: 'eyJhmMiJBMTO...diI4QT' } });
+export const refreshTokenResponseSchema = yupString().meta({ openapiField: { description: 'Long-lived refresh token that can be used to obtain a new access token', exampleValue: 'i8nsoaq2...14y' } });
+export const signInResponseSchema = yupObject({
     refresh_token: refreshTokenResponseSchema.required(),
     access_token: accessTokenResponseSchema.required(),
-    is_new_user: yup.boolean().meta({ openapiField: { description: 'Whether the user is a new user', exampleValue: true } }).required(),
-    user_id: userIdResponseSchema.required(),
+    is_new_user: yupBoolean().meta({ openapiField: { description: 'Whether the user is a new user', exampleValue: true } }).required(),
+    user_id: userIdSchema.required(),
 });
+// Permissions
+export const teamSystemPermissions = [
+    '$update_team',
+    '$delete_team',
+    '$read_members',
+    '$remove_members',
+    '$invite_members',
+];
+export const teamPermissionIdSchema = yupString()
+    .matches(/^\$?[a-z0-9_:]+$/, 'Only lowercase letters, numbers, ":", "_" and optional "$" at the beginning are allowed')
+    .test('is-system-permission', 'System permissions must start with a dollar sign', (value, ctx) => {
+    if (!value)
+        return true;
+    if (value.startsWith('$') && !teamSystemPermissions.includes(value)) {
+        return ctx.createError({ message: 'Invalid system permission' });
+    }
+    return true;
+})
+    .meta({ openapiField: { description: `The permission ID used to uniquely identify a permission. Can either be a custom permission with lowercase letters, numbers, ":", and "_" characters, or one of the system permissions: ${teamSystemPermissions.join(', ')}`, exampleValue: '$read_secret_info' } });
+export const customTeamPermissionIdSchema = yupString()
+    .matches(/^[a-z0-9_:]+$/, 'Only lowercase letters, numbers, ":", "_" are allowed')
+    .meta({ openapiField: { description: 'The permission ID used to uniquely identify a permission. Can only contain lowercase letters, numbers, ":", and "_" characters', exampleValue: 'read_secret_info' } });
+export const teamPermissionDescriptionSchema = yupString().meta({ openapiField: { description: 'A human-readable description of the permission', exampleValue: 'Read secret information' } });
+export const containedPermissionIdsSchema = yupArray(teamPermissionIdSchema.required()).meta({ openapiField: { description: 'The IDs of the permissions that are contained in this permission', exampleValue: ['read_public_info'] } });
+// Teams
+export const teamIdSchema = yupString().uuid().meta({ openapiField: { description: _idDescription('team'), exampleValue: 'ad962777-8244-496a-b6a2-e0c6a449c79e' } });
+export const teamDisplayNameSchema = yupString().meta({ openapiField: { description: _displayNameDescription('team'), exampleValue: 'My Team' } });
+export const teamClientMetadataSchema = jsonSchema.meta({ openapiField: { description: _clientMetaDataDescription('team'), exampleValue: { key: 'value' } } });
+export const teamServerMetadataSchema = jsonSchema.meta({ openapiField: { description: _serverMetaDataDescription('team'), exampleValue: { key: 'value' } } });
+export const teamCreatedAtMillisSchema = yupNumber().meta({ openapiField: { description: _createdAtMillisDescription('team'), exampleValue: 1630000000000 } });
+// Utils
+export function yupRequiredWhen(schema, triggerName, isValue) {
+    return schema.when(triggerName, {
+        is: isValue,
+        then: (schema) => schema.required(),
+        otherwise: (schema) => schema.optional()
+    });
+}

package/dist/sessions.d.ts

@@ -42,6 +42,7 @@ export declare class InternalSession {
         refreshToken: string | null;
         accessToken?: string | null;
     }): string;
+    isKnownToBeInvalid(): boolean;
     /**
      * Marks the session object as invalid, meaning that the refresh and access tokens can no longer be used.
      */

package/dist/sessions.js

@@ -1,14 +1,19 @@
+import { StackAssertionError } from "./utils/errors";
 import { Store } from "./utils/stores";
 export class AccessToken {
-    token;
     constructor(token) {
         this.token = token;
+        if (token === "undefined") {
+            throw new StackAssertionError("Access token is the string 'undefined'; it's unlikely this is the correct value. They're supposed to be unguessable!");
+        }
     }
 }
 export class RefreshToken {
-    token;
     constructor(token) {
         this.token = token;
+        if (token === "undefined") {
+            throw new StackAssertionError("Refresh token is the string 'undefined'; it's unlikely this is the correct value. They're supposed to be unguessable!");
+        }
     }
 }
 /**
@@ -17,29 +22,15 @@ export class RefreshToken {
  * A session never changes which user or session it belongs to, but the tokens in it may change over time.
  */
 export class InternalSession {
-    _options;
-    /**
-    * Each session has a session key that depends on the tokens inside. If the session has a refresh token, the session key depends only on the refresh token. If the session does not have a refresh token, the session key depends only on the access token.
-    *
-    * Multiple Session objects may have the same session key, which implies that they represent the same session by the same user. Furthermore, a session's key never changes over the lifetime of a session object.
-    *
-    * This is useful for caching and indexing sessions.
-    */
-    sessionKey;
-    /**
-     * An access token that is not known to be invalid (ie. may be valid, but may have expired).
-     */
-    _accessToken;
-    _refreshToken;
-    /**
-     * Whether the session as a whole is known to be invalid. Used as a cache to avoid making multiple requests to the server (sessions never go back to being valid after being invalidated).
-     *
-     * Applies to both the access token and the refresh token (it is possible for the access token to be invalid but the refresh token to be valid, in which case the session is still valid).
-     */
-    _knownToBeInvalid = new Store(false);
-    _refreshPromise = null;
     constructor(_options) {
         this._options = _options;
+        /**
+         * Whether the session as a whole is known to be invalid. Used as a cache to avoid making multiple requests to the server (sessions never go back to being valid after being invalidated).
+         *
+         * Applies to both the access token and the refresh token (it is possible for the access token to be invalid but the refresh token to be valid, in which case the session is still valid).
+         */
+        this._knownToBeInvalid = new Store(false);
+        this._refreshPromise = null;
         this._accessToken = new Store(_options.accessToken ? new AccessToken(_options.accessToken) : null);
         this._refreshToken = _options.refreshToken ? new RefreshToken(_options.refreshToken) : null;
         this.sessionKey = InternalSession.calculateSessionKey({ accessToken: _options.accessToken ?? null, refreshToken: _options.refreshToken });
@@ -55,6 +46,9 @@ export class InternalSession {
             return "not-logged-in";
         }
     }
+    isKnownToBeInvalid() {
+        return this._knownToBeInvalid.get();
+    }
     /**
      * Marks the session object as invalid, meaning that the refresh and access tokens can no longer be used.
      */
@@ -104,13 +98,13 @@ export class InternalSession {
      * @returns An access token (cached if possible), or null if the session either does not represent a user or the session is invalid.
      */
     async _getPotentiallyExpiredAccessToken() {
-        const oldAccessToken = this._accessToken.get();
-        if (oldAccessToken)
-            return oldAccessToken;
         if (!this._refreshToken)
             return null;
         if (this._knownToBeInvalid.get())
             return null;
+        const oldAccessToken = this._accessToken.get();
+        if (oldAccessToken)
+            return oldAccessToken;
         // refresh access token
         if (!this._refreshPromise) {
             this._refreshAndSetRefreshPromise(this._refreshToken);

package/dist/utils/arrays.d.ts

@@ -1,6 +1,10 @@
 export declare function typedIncludes<T extends readonly any[]>(arr: T, item: unknown): item is T[number];
 export declare function enumerate<T extends readonly any[]>(arr: T): [number, T[number]][];
 export declare function isShallowEqual(a: readonly any[], b: readonly any[]): boolean;
+/**
+ * Ponyfill for ES2023's findLastIndex.
+ */
+export declare function findLastIndex<T>(arr: readonly T[], predicate: (item: T) => boolean): number;
 export declare function groupBy<T extends any, K>(arr: Iterable<T>, key: (item: T) => K): Map<K, T[]>;
 export declare function range(endExclusive: number): number[];
 export declare function range(startInclusive: number, endExclusive: number): number[];

package/dist/utils/arrays.js

@@ -14,6 +14,16 @@ export function isShallowEqual(a, b) {
     }
     return true;
 }
+/**
+ * Ponyfill for ES2023's findLastIndex.
+ */
+export function findLastIndex(arr, predicate) {
+    for (let i = arr.length - 1; i >= 0; i--) {
+        if (predicate(arr[i]))
+            return i;
+    }
+    return -1;
+}
 export function groupBy(arr, key) {
     const result = new Map;
     for (const item of arr) {

package/dist/utils/caches.js

@@ -17,12 +17,18 @@ export function cacheFunction(f) {
     });
 }
 export class AsyncCache {
-    _fetcher;
-    _options;
-    _map = new DependenciesMap();
     constructor(_fetcher, _options = {}) {
         this._fetcher = _fetcher;
         this._options = _options;
+        this._map = new DependenciesMap();
+        this.isCacheAvailable = this._createKeyed("isCacheAvailable");
+        this.getIfCached = this._createKeyed("getIfCached");
+        this.getOrWait = this._createKeyed("getOrWait");
+        this.forceSetCachedValue = this._createKeyed("forceSetCachedValue");
+        this.forceSetCachedValueAsync = this._createKeyed("forceSetCachedValueAsync");
+        this.refresh = this._createKeyed("refresh");
+        this.invalidate = this._createKeyed("invalidate");
+        this.onStateChange = this._createKeyed("onStateChange");
         // nothing here yet
     }
     _createKeyed(functionName) {
@@ -42,25 +48,12 @@ export class AsyncCache {
         }
         return cache;
     }
-    isCacheAvailable = this._createKeyed("isCacheAvailable");
-    getIfCached = this._createKeyed("getIfCached");
-    getOrWait = this._createKeyed("getOrWait");
-    forceSetCachedValue = this._createKeyed("forceSetCachedValue");
-    forceSetCachedValueAsync = this._createKeyed("forceSetCachedValueAsync");
-    refresh = this._createKeyed("refresh");
-    invalidate = this._createKeyed("invalidate");
-    onStateChange = this._createKeyed("onStateChange");
 }
 class AsyncValueCache {
-    _options;
-    _store;
-    _pendingPromise;
-    _fetcher;
-    _rateLimitOptions;
-    _subscriptionsCount = 0;
-    _unsubscribers = [];
     constructor(fetcher, _options = {}) {
         this._options = _options;
+        this._subscriptionsCount = 0;
+        this._unsubscribers = [];
         this._store = new AsyncStore();
         this._rateLimitOptions = {
             concurrency: 1,

package/dist/utils/compile-time.d.ts

@@ -1,4 +1,6 @@
 /**
- * Returns the first argument passed to it, but compilers won't be able to optimize it out. This is useful in some cases where compiler warnings go awry; for example, when importing things that may not exist (but are guaranteed to exist at runtime).
+ * Returns the first argument passed to it, but compilers won't be able to optimize it out. This is useful in some
+ * cases where compiler warnings go awry; for example, when importing things that may not exist (but are guaranteed
+ * to exist at runtime).
  */
 export declare function scrambleDuringCompileTime<T>(t: T): T;

package/dist/utils/compile-time.js

@@ -1,5 +1,7 @@
 /**
- * Returns the first argument passed to it, but compilers won't be able to optimize it out. This is useful in some cases where compiler warnings go awry; for example, when importing things that may not exist (but are guaranteed to exist at runtime).
+ * Returns the first argument passed to it, but compilers won't be able to optimize it out. This is useful in some
+ * cases where compiler warnings go awry; for example, when importing things that may not exist (but are guaranteed
+ * to exist at runtime).
  */
 export function scrambleDuringCompileTime(t) {
     return t;

package/dist/utils/errors.d.ts

@@ -13,8 +13,11 @@ type Status = {
     message: string;
 };
 type StatusErrorConstructorParameters = [
-    statusCode: number | Status,
+    status: Status,
     message?: string
+] | [
+    statusCode: number | Status,
+    message: string
 ];
 export declare class StatusError extends Error {
     name: string;
@@ -185,6 +188,10 @@ export declare class StatusError extends Error {
     getStatusCode(): number;
     getBody(): Uint8Array;
     getHeaders(): Record<string, string[]>;
+    toDescriptiveJson(): Json;
+    /**
+     * @deprecated this is not a good way to make status errors human-readable, use toDescriptiveJson instead
+     */
     toHttpJson(): Json;
 }
 export {};

package/dist/utils/errors.js

@@ -12,7 +12,6 @@ export function throwErr(...args) {
     }
 }
 export class StackAssertionError extends Error {
-    extraData;
     constructor(message, extraData, options) {
         const disclaimer = `\n\nThis is likely an error in Stack. Please report it.`;
         super(`${message}${message.endsWith(disclaimer) ? "" : disclaimer}`, options);
@@ -28,11 +27,11 @@ export function registerErrorSink(sink) {
     errorSinks.add(sink);
 }
 registerErrorSink((location, ...args) => {
-    console.error(`Error in ${location}:`, ...args);
+    console.error(`\x1b[41mError in ${location}:`, ...args, "\x1b[0m");
 });
-registerErrorSink((location, error, ...args) => {
+registerErrorSink((location, error, ...extraArgs) => {
     globalVar.stackCapturedErrors = globalVar.stackCapturedErrors ?? [];
-    globalVar.stackCapturedErrors.push({ location, error: args, extraArgs: args });
+    globalVar.stackCapturedErrors.push({ location, error, extraArgs });
 });
 export function captureError(location, error) {
     for (const sink of errorSinks) {
@@ -40,56 +39,17 @@ export function captureError(location, error) {
     }
 }
 export class StatusError extends Error {
-    name = "StatusError";
-    statusCode;
-    static BadRequest = { statusCode: 400, message: "Bad Request" };
-    static Unauthorized = { statusCode: 401, message: "Unauthorized" };
-    static PaymentRequired = { statusCode: 402, message: "Payment Required" };
-    static Forbidden = { statusCode: 403, message: "Forbidden" };
-    static NotFound = { statusCode: 404, message: "Not Found" };
-    static MethodNotAllowed = { statusCode: 405, message: "Method Not Allowed" };
-    static NotAcceptable = { statusCode: 406, message: "Not Acceptable" };
-    static ProxyAuthenticationRequired = { statusCode: 407, message: "Proxy Authentication Required" };
-    static RequestTimeout = { statusCode: 408, message: "Request Timeout" };
-    static Conflict = { statusCode: 409, message: "Conflict" };
-    static Gone = { statusCode: 410, message: "Gone" };
-    static LengthRequired = { statusCode: 411, message: "Length Required" };
-    static PreconditionFailed = { statusCode: 412, message: "Precondition Failed" };
-    static PayloadTooLarge = { statusCode: 413, message: "Payload Too Large" };
-    static URITooLong = { statusCode: 414, message: "URI Too Long" };
-    static UnsupportedMediaType = { statusCode: 415, message: "Unsupported Media Type" };
-    static RangeNotSatisfiable = { statusCode: 416, message: "Range Not Satisfiable" };
-    static ExpectationFailed = { statusCode: 417, message: "Expectation Failed" };
-    static ImATeapot = { statusCode: 418, message: "I'm a teapot" };
-    static MisdirectedRequest = { statusCode: 421, message: "Misdirected Request" };
-    static UnprocessableEntity = { statusCode: 422, message: "Unprocessable Entity" };
-    static Locked = { statusCode: 423, message: "Locked" };
-    static FailedDependency = { statusCode: 424, message: "Failed Dependency" };
-    static TooEarly = { statusCode: 425, message: "Too Early" };
-    static UpgradeRequired = { statusCode: 426, message: "Upgrade Required" };
-    static PreconditionRequired = { statusCode: 428, message: "Precondition Required" };
-    static TooManyRequests = { statusCode: 429, message: "Too Many Requests" };
-    static RequestHeaderFieldsTooLarge = { statusCode: 431, message: "Request Header Fields Too Large" };
-    static UnavailableForLegalReasons = { statusCode: 451, message: "Unavailable For Legal Reasons" };
-    static InternalServerError = { statusCode: 500, message: "Internal Server Error" };
-    static NotImplemented = { statusCode: 501, message: "Not Implemented" };
-    static BadGateway = { statusCode: 502, message: "Bad Gateway" };
-    static ServiceUnavailable = { statusCode: 503, message: "Service Unavailable" };
-    static GatewayTimeout = { statusCode: 504, message: "Gateway Timeout" };
-    static HTTPVersionNotSupported = { statusCode: 505, message: "HTTP Version Not Supported" };
-    static VariantAlsoNegotiates = { statusCode: 506, message: "Variant Also Negotiates" };
-    static InsufficientStorage = { statusCode: 507, message: "Insufficient Storage" };
-    static LoopDetected = { statusCode: 508, message: "Loop Detected" };
-    static NotExtended = { statusCode: 510, message: "Not Extended" };
-    static NetworkAuthenticationRequired = { statusCode: 511, message: "Network Authentication Required" };
     constructor(status, message) {
         if (typeof status === "object") {
             message ??= status.message;
             status = status.statusCode;
         }
-        message ??= "Server Error";
         super(message);
+        this.name = "StatusError";
         this.statusCode = status;
+        if (!message) {
+            throw new StackAssertionError("StatusError always requires a message unless a Status object is passed", {}, { cause: this });
+        }
     }
     isClientError() {
         return this.statusCode >= 400 && this.statusCode < 500;
@@ -108,6 +68,16 @@ export class StatusError extends Error {
             "Content-Type": ["text/plain; charset=utf-8"],
         };
     }
+    toDescriptiveJson() {
+        return {
+            status_code: this.getStatusCode(),
+            message: this.message,
+            headers: this.getHeaders(),
+        };
+    }
+    /**
+     * @deprecated this is not a good way to make status errors human-readable, use toDescriptiveJson instead
+     */
     toHttpJson() {
         return {
             status_code: this.statusCode,
@@ -116,3 +86,44 @@ export class StatusError extends Error {
         };
     }
 }
+StatusError.BadRequest = { statusCode: 400, message: "Bad Request" };
+StatusError.Unauthorized = { statusCode: 401, message: "Unauthorized" };
+StatusError.PaymentRequired = { statusCode: 402, message: "Payment Required" };
+StatusError.Forbidden = { statusCode: 403, message: "Forbidden" };
+StatusError.NotFound = { statusCode: 404, message: "Not Found" };
+StatusError.MethodNotAllowed = { statusCode: 405, message: "Method Not Allowed" };
+StatusError.NotAcceptable = { statusCode: 406, message: "Not Acceptable" };
+StatusError.ProxyAuthenticationRequired = { statusCode: 407, message: "Proxy Authentication Required" };
+StatusError.RequestTimeout = { statusCode: 408, message: "Request Timeout" };
+StatusError.Conflict = { statusCode: 409, message: "Conflict" };
+StatusError.Gone = { statusCode: 410, message: "Gone" };
+StatusError.LengthRequired = { statusCode: 411, message: "Length Required" };
+StatusError.PreconditionFailed = { statusCode: 412, message: "Precondition Failed" };
+StatusError.PayloadTooLarge = { statusCode: 413, message: "Payload Too Large" };
+StatusError.URITooLong = { statusCode: 414, message: "URI Too Long" };
+StatusError.UnsupportedMediaType = { statusCode: 415, message: "Unsupported Media Type" };
+StatusError.RangeNotSatisfiable = { statusCode: 416, message: "Range Not Satisfiable" };
+StatusError.ExpectationFailed = { statusCode: 417, message: "Expectation Failed" };
+StatusError.ImATeapot = { statusCode: 418, message: "I'm a teapot" };
+StatusError.MisdirectedRequest = { statusCode: 421, message: "Misdirected Request" };
+StatusError.UnprocessableEntity = { statusCode: 422, message: "Unprocessable Entity" };
+StatusError.Locked = { statusCode: 423, message: "Locked" };
+StatusError.FailedDependency = { statusCode: 424, message: "Failed Dependency" };
+StatusError.TooEarly = { statusCode: 425, message: "Too Early" };
+StatusError.UpgradeRequired = { statusCode: 426, message: "Upgrade Required" };
+StatusError.PreconditionRequired = { statusCode: 428, message: "Precondition Required" };
+StatusError.TooManyRequests = { statusCode: 429, message: "Too Many Requests" };
+StatusError.RequestHeaderFieldsTooLarge = { statusCode: 431, message: "Request Header Fields Too Large" };
+StatusError.UnavailableForLegalReasons = { statusCode: 451, message: "Unavailable For Legal Reasons" };
+StatusError.InternalServerError = { statusCode: 500, message: "Internal Server Error" };
+StatusError.NotImplemented = { statusCode: 501, message: "Not Implemented" };
+StatusError.BadGateway = { statusCode: 502, message: "Bad Gateway" };
+StatusError.ServiceUnavailable = { statusCode: 503, message: "Service Unavailable" };
+StatusError.GatewayTimeout = { statusCode: 504, message: "Gateway Timeout" };
+StatusError.HTTPVersionNotSupported = { statusCode: 505, message: "HTTP Version Not Supported" };
+StatusError.VariantAlsoNegotiates = { statusCode: 506, message: "Variant Also Negotiates" };
+StatusError.InsufficientStorage = { statusCode: 507, message: "Insufficient Storage" };
+StatusError.LoopDetected = { statusCode: 508, message: "Loop Detected" };
+StatusError.NotExtended = { statusCode: 510, message: "Not Extended" };
+StatusError.NetworkAuthenticationRequired = { statusCode: 511, message: "Network Authentication Required" };
+StatusError.prototype.name = "StatusError";

package/dist/utils/globals.js

@@ -4,6 +4,9 @@ const globalVar = typeof globalThis !== 'undefined' ? globalThis :
             typeof self !== 'undefined' ? self :
                 {};
 export { globalVar, };
+if (typeof globalThis === 'undefined') {
+    globalVar.globalThis = globalVar;
+}
 const stackGlobalsSymbol = Symbol.for('__stack-globals');
 globalVar[stackGlobalsSymbol] ??= {};
 export function createGlobal(key, init) {

package/dist/utils/maps.js

@@ -1,8 +1,8 @@
+var _a, _b;
 import { Result } from "./results";
 export class MaybeWeakMap {
-    _primitiveMap;
-    _weakMap;
     constructor(entries) {
+        this[_a] = "MaybeWeakMap";
         const entriesArray = [...entries ?? []];
         this._primitiveMap = new Map(entriesArray.filter((e) => !this._isAllowedInWeakMap(e[0])));
         this._weakMap = new WeakMap(entriesArray.filter((e) => this._isAllowedInWeakMap(e[0])));
@@ -43,10 +43,13 @@ export class MaybeWeakMap {
             return this._primitiveMap.has(key);
         }
     }
-    [Symbol.toStringTag] = "MaybeWeakMap";
 }
+_a = Symbol.toStringTag;
 export class DependenciesMap {
-    _inner = { map: new MaybeWeakMap(), hasValue: false, value: undefined };
+    constructor() {
+        this._inner = { map: new MaybeWeakMap(), hasValue: false, value: undefined };
+        this[_b] = "DependenciesMap";
+    }
     _valueToResult(inner) {
         if (inner.hasValue) {
             return Result.ok(inner.value);
@@ -106,5 +109,5 @@ export class DependenciesMap {
     clear() {
         this._inner = { map: new MaybeWeakMap(), hasValue: false, value: undefined };
     }
-    [Symbol.toStringTag] = "DependenciesMap";
 }
+_b = Symbol.toStringTag;