toiljs 0.0.94 → 0.0.96

package/build/client/auth.d.ts

@@ -23,13 +23,53 @@ export interface AuthOptions {
 }
 export declare function register(username: string, password: string, email: string, opts?: AuthOptions): Promise<void>;
 export declare function login(username: string, password: string, opts?: AuthOptions): Promise<Uint8Array>;
-export declare class EmailNotConfirmedError extends Error {
+export declare enum AuthErrorCode {
+    RequestFailed = "request_failed",
+    ProtocolError = "protocol_error",
+    UsernameTaken = "username_taken",
+    EmailInUse = "email_in_use",
+    RegistrationRejected = "registration_rejected",
+    InvalidCredentials = "invalid_credentials",
+    EmailNotConfirmed = "email_not_confirmed",
+    TwoFactorRequired = "two_factor_required",
+    ServerAuthFailed = "server_auth_failed",
+    TwoFactorCodeInvalid = "two_factor_code_invalid",
+    TwoFactorSetupFailed = "two_factor_setup_failed",
+    ConfirmationInvalid = "confirmation_invalid",
+    PasswordResetInvalid = "password_reset_invalid"
+}
+export declare class AuthError extends Error {
+    readonly code: AuthErrorCode;
+    constructor(code: AuthErrorCode, message: string);
+}
+export declare class UsernameTakenError extends AuthError {
+    constructor();
+}
+export declare class EmailInUseError extends AuthError {
+    constructor();
+}
+export declare class InvalidCredentialsError extends AuthError {
+    constructor();
+}
+export declare class EmailNotConfirmedError extends AuthError {
     constructor();
 }
-export declare class TwoFactorRequiredError extends Error {
+export declare class TwoFactorRequiredError extends AuthError {
     readonly twoFaId: string;
     constructor(twoFaId: string);
 }
+export declare class ServerAuthFailedError extends AuthError {
+    constructor();
+}
+export declare class TwoFactorCodeError extends AuthError {
+    constructor();
+}
+export declare class ConfirmationInvalidError extends AuthError {
+    constructor();
+}
+export declare class PasswordResetInvalidError extends AuthError {
+    constructor();
+}
 export declare const TwoFactorMethod: {
     readonly None: 0;
     readonly Email: 1;
@@ -59,4 +99,15 @@ export declare const Auth: {
     };
     readonly buildLoginMessage: typeof buildLoginMessage;
     readonly LOGIN_CONTEXT: "qauth:login:v1";
+    readonly AuthError: typeof AuthError;
+    readonly AuthErrorCode: typeof AuthErrorCode;
+    readonly UsernameTakenError: typeof UsernameTakenError;
+    readonly EmailInUseError: typeof EmailInUseError;
+    readonly InvalidCredentialsError: typeof InvalidCredentialsError;
+    readonly EmailNotConfirmedError: typeof EmailNotConfirmedError;
+    readonly TwoFactorRequiredError: typeof TwoFactorRequiredError;
+    readonly ServerAuthFailedError: typeof ServerAuthFailedError;
+    readonly TwoFactorCodeError: typeof TwoFactorCodeError;
+    readonly ConfirmationInvalidError: typeof ConfirmationInvalidError;
+    readonly PasswordResetInvalidError: typeof PasswordResetInvalidError;
 };

package/build/client/auth.js

@@ -110,7 +110,7 @@ async function postBinary(baseUrl, path, body) {
         credentials: 'same-origin',
     });
     if (!res.ok)
-        throw new Error('auth: request failed');
+        throw new AuthError(AuthErrorCode.RequestFailed, 'The auth request failed.');
     return new DataReader(new Uint8Array(await res.arrayBuffer()));
 }
 export async function register(username, password, email, opts = {}) {
@@ -121,7 +121,7 @@ export async function register(username, password, email, opts = {}) {
     const start = await postBinary(baseUrl, '/register/start', new DataWriter().writeString(username).writeBytes(blinded).toBytes());
     const status = start.readU8();
     if (status !== 0)
-        throw new Error('auth: registration unavailable');
+        throw new AuthError(AuthErrorCode.RequestFailed, 'Registration is unavailable right now.');
     const kdf = decodeKdf(start);
     const evaluated = start.readBytes();
     const oprfOutput = oprf.finalize(pw, blind, evaluated);
@@ -144,7 +144,7 @@ export async function register(username, password, email, opts = {}) {
         wipe(seed);
     }
     if (publicKey.length !== PUBLIC_KEY_LEN)
-        throw new Error('auth: bad public key length');
+        throw new AuthError(AuthErrorCode.ProtocolError, 'Server returned a bad public key length.');
     const finish = await postBinary(baseUrl, '/register/finish', new DataWriter()
         .writeString(username)
         .writeString(email)
@@ -153,11 +153,11 @@ export async function register(username, password, email, opts = {}) {
         .toBytes());
     const finishStatus = finish.readU8();
     if (finishStatus === 1)
-        throw new Error('auth: username already registered (log in instead)');
+        throw new UsernameTakenError();
     if (finishStatus === 2)
-        throw new Error('auth: email already in use');
+        throw new EmailInUseError();
     if (finishStatus !== 0)
-        throw new Error('auth: registration rejected');
+        throw new AuthError(AuthErrorCode.RegistrationRejected, 'Registration was rejected.');
 }
 export async function login(username, password, opts = {}) {
     const baseUrl = opts.baseUrl ?? '/auth';
@@ -173,7 +173,7 @@ export async function login(username, password, opts = {}) {
     const exp = r.readU64();
     const evaluated = r.readBytes();
     if (BigInt(Math.floor(Date.now() / 1000)) >= exp)
-        throw new Error('auth: challenge expired');
+        throw new AuthError(AuthErrorCode.ProtocolError, 'The login challenge expired; retry.');
     const oprfOutput = oprf.finalize(pw, blind, evaluated);
     const seed = await deriveSeed(oprfOutput, kdf);
     const { cipherText, sharedSecret } = ml_kem768.encapsulate(SERVER_KEM_PUBLIC_KEY);
@@ -193,7 +193,7 @@ export async function login(username, password, opts = {}) {
         wipe(seed);
     }
     if (signature.length !== SIGNATURE_LEN)
-        throw new Error('auth: bad signature length');
+        throw new AuthError(AuthErrorCode.ProtocolError, 'Computed a bad signature length.');
     const res = await postBinary(baseUrl, '/login/finish', new DataWriter().writeBytes(cid).writeBytes(cipherText).writeBytes(signature).toBytes());
     const loginStatus = res.readU8();
     if (loginStatus === 2) {
@@ -202,7 +202,7 @@ export async function login(username, password, opts = {}) {
     }
     if (loginStatus !== 0 && loginStatus !== 3) {
         wipe(sharedSecret);
-        throw new Error('auth: login failed');
+        throw new InvalidCredentialsError();
     }
     const first = res.readBytes();
     const serverConfirm = res.readBytes();
@@ -211,45 +211,111 @@ export async function login(username, password, opts = {}) {
     wipe(sharedSecret);
     const expected = await hmacSha256(sessionKey, concatBytes(utf8(SERVER_CONFIRM_LABEL), transcriptHash));
     if (!bytesEqual(expected, serverConfirm))
-        throw new Error('auth: server authentication failed');
+        throw new ServerAuthFailedError();
     if (loginStatus === 3) {
         throw new TwoFactorRequiredError(toHex(first));
     }
     return first;
 }
-export class EmailNotConfirmedError extends Error {
+export var AuthErrorCode;
+(function (AuthErrorCode) {
+    AuthErrorCode["RequestFailed"] = "request_failed";
+    AuthErrorCode["ProtocolError"] = "protocol_error";
+    AuthErrorCode["UsernameTaken"] = "username_taken";
+    AuthErrorCode["EmailInUse"] = "email_in_use";
+    AuthErrorCode["RegistrationRejected"] = "registration_rejected";
+    AuthErrorCode["InvalidCredentials"] = "invalid_credentials";
+    AuthErrorCode["EmailNotConfirmed"] = "email_not_confirmed";
+    AuthErrorCode["TwoFactorRequired"] = "two_factor_required";
+    AuthErrorCode["ServerAuthFailed"] = "server_auth_failed";
+    AuthErrorCode["TwoFactorCodeInvalid"] = "two_factor_code_invalid";
+    AuthErrorCode["TwoFactorSetupFailed"] = "two_factor_setup_failed";
+    AuthErrorCode["ConfirmationInvalid"] = "confirmation_invalid";
+    AuthErrorCode["PasswordResetInvalid"] = "password_reset_invalid";
+})(AuthErrorCode || (AuthErrorCode = {}));
+export class AuthError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'AuthError';
+        this.code = code;
+    }
+}
+export class UsernameTakenError extends AuthError {
+    constructor() {
+        super(AuthErrorCode.UsernameTaken, 'That username is already registered.');
+        this.name = 'UsernameTakenError';
+    }
+}
+export class EmailInUseError extends AuthError {
+    constructor() {
+        super(AuthErrorCode.EmailInUse, 'That email is already in use.');
+        this.name = 'EmailInUseError';
+    }
+}
+export class InvalidCredentialsError extends AuthError {
+    constructor() {
+        super(AuthErrorCode.InvalidCredentials, 'Incorrect username or password.');
+        this.name = 'InvalidCredentialsError';
+    }
+}
+export class EmailNotConfirmedError extends AuthError {
     constructor() {
-        super('auth: email not confirmed');
+        super(AuthErrorCode.EmailNotConfirmed, 'Your email address is not confirmed yet.');
         this.name = 'EmailNotConfirmedError';
     }
 }
-export class TwoFactorRequiredError extends Error {
+export class TwoFactorRequiredError extends AuthError {
     twoFaId;
     constructor(twoFaId) {
-        super('auth: two-factor authentication required');
+        super(AuthErrorCode.TwoFactorRequired, 'A second factor is required to sign in.');
         this.name = 'TwoFactorRequiredError';
         this.twoFaId = twoFaId;
     }
 }
+export class ServerAuthFailedError extends AuthError {
+    constructor() {
+        super(AuthErrorCode.ServerAuthFailed, 'Server authentication failed (possible MITM).');
+        this.name = 'ServerAuthFailedError';
+    }
+}
+export class TwoFactorCodeError extends AuthError {
+    constructor() {
+        super(AuthErrorCode.TwoFactorCodeInvalid, 'The verification code is invalid or expired.');
+        this.name = 'TwoFactorCodeError';
+    }
+}
+export class ConfirmationInvalidError extends AuthError {
+    constructor() {
+        super(AuthErrorCode.ConfirmationInvalid, 'This confirmation link is invalid or has expired.');
+        this.name = 'ConfirmationInvalidError';
+    }
+}
+export class PasswordResetInvalidError extends AuthError {
+    constructor() {
+        super(AuthErrorCode.PasswordResetInvalid, 'This password-reset link is invalid or has expired.');
+        this.name = 'PasswordResetInvalidError';
+    }
+}
 export const TwoFactorMethod = { None: 0, Email: 1 };
 export async function verifyTwoFactor(twoFaId, code, opts = {}) {
     const baseUrl = opts.baseUrl ?? '/auth';
     const res = await postBinary(baseUrl, '/2fa/verify', new DataWriter().writeBytes(fromHex(twoFaId)).writeString(code).toBytes());
     if (res.readU8() !== 0)
-        throw new Error('auth: two-factor code invalid or expired');
+        throw new TwoFactorCodeError();
     return res.readBytes();
 }
 export async function setupTwoFactor(method, opts = {}) {
     const baseUrl = opts.baseUrl ?? '/auth';
     const res = await postBinary(baseUrl, '/2fa/setup', new DataWriter().writeU8(method).toBytes());
     if (res.readU8() !== 0)
-        throw new Error('auth: two-factor setup failed');
+        throw new AuthError(AuthErrorCode.TwoFactorSetupFailed, 'Enabling or disabling two-factor failed.');
 }
 export async function confirmTwoFactorSetup(code, opts = {}) {
     const baseUrl = opts.baseUrl ?? '/auth';
     const res = await postBinary(baseUrl, '/2fa/setup/verify', new DataWriter().writeString(code).toBytes());
     if (res.readU8() !== 0)
-        throw new Error('auth: two-factor setup confirmation failed');
+        throw new AuthError(AuthErrorCode.TwoFactorSetupFailed, 'Confirming the two-factor setup failed.');
 }
 export async function twoFactorStatus(opts = {}) {
     const baseUrl = opts.baseUrl ?? '/auth';
@@ -258,14 +324,14 @@ export async function twoFactorStatus(opts = {}) {
         credentials: 'same-origin',
     });
     if (!res.ok)
-        throw new Error('auth: request failed');
+        throw new AuthError(AuthErrorCode.RequestFailed, 'The auth request failed.');
     return new DataReader(new Uint8Array(await res.arrayBuffer())).readU8();
 }
 export async function confirmEmail(token, opts = {}) {
     const baseUrl = opts.baseUrl ?? '/auth';
     const res = await postBinary(baseUrl, '/confirm', new DataWriter().writeBytes(fromHex(token)).toBytes());
     if (res.readU8() !== 0)
-        throw new Error('auth: confirmation link invalid or expired');
+        throw new ConfirmationInvalidError();
 }
 export async function resendConfirmation(email, opts = {}) {
     const baseUrl = opts.baseUrl ?? '/auth';
@@ -283,7 +349,7 @@ export async function resetPassword(token, newPassword, opts = {}) {
     const { blind, blinded } = oprf.blind(pw);
     const start = await postBinary(baseUrl, '/reset/start', new DataWriter().writeBytes(rawToken).writeBytes(blinded).toBytes());
     if (start.readU8() !== 0)
-        throw new Error('auth: reset link invalid or expired');
+        throw new PasswordResetInvalidError();
     const username = start.readString();
     const kdf = decodeKdf(start);
     const evaluated = start.readBytes();
@@ -307,10 +373,10 @@ export async function resetPassword(token, newPassword, opts = {}) {
         wipe(seed);
     }
     if (publicKey.length !== PUBLIC_KEY_LEN)
-        throw new Error('auth: bad public key length');
+        throw new AuthError(AuthErrorCode.ProtocolError, 'Server returned a bad public key length.');
     const finish = await postBinary(baseUrl, '/reset/finish', new DataWriter().writeBytes(rawToken).writeBytes(publicKey).writeBytes(regProof).toBytes());
     if (finish.readU8() !== 0)
-        throw new Error('auth: password reset rejected');
+        throw new PasswordResetInvalidError();
 }
 export const Auth = {
     register,
@@ -326,4 +392,15 @@ export const Auth = {
     TwoFactorMethod,
     buildLoginMessage,
     LOGIN_CONTEXT,
+    AuthError,
+    AuthErrorCode,
+    UsernameTakenError,
+    EmailInUseError,
+    InvalidCredentialsError,
+    EmailNotConfirmedError,
+    TwoFactorRequiredError,
+    ServerAuthFailedError,
+    TwoFactorCodeError,
+    ConfirmationInvalidError,
+    PasswordResetInvalidError,
 };

package/build/client/index.d.ts

@@ -1,6 +1,6 @@
 export { mount } from './routing/mount.js';
 export { Router } from './routing/Router.js';
-export { Auth, register as authRegister, login as authLogin, buildLoginMessage, LOGIN_CONTEXT, } from './auth.js';
+export { Auth, register as authRegister, login as authLogin, buildLoginMessage, LOGIN_CONTEXT, AuthError, AuthErrorCode, UsernameTakenError, EmailInUseError, InvalidCredentialsError, EmailNotConfirmedError, TwoFactorRequiredError, ServerAuthFailedError, TwoFactorCodeError, ConfirmationInvalidError, PasswordResetInvalidError, } from './auth.js';
 export type { KdfParams, AuthOptions } from './auth.js';
 export { Link } from './navigation/Link.js';
 export type { LinkProps } from './navigation/Link.js';

package/build/client/index.js

@@ -1,6 +1,6 @@
 export { mount } from './routing/mount.js';
 export { Router } from './routing/Router.js';
-export { Auth, register as authRegister, login as authLogin, buildLoginMessage, LOGIN_CONTEXT, } from './auth.js';
+export { Auth, register as authRegister, login as authLogin, buildLoginMessage, LOGIN_CONTEXT, AuthError, AuthErrorCode, UsernameTakenError, EmailInUseError, InvalidCredentialsError, EmailNotConfirmedError, TwoFactorRequiredError, ServerAuthFailedError, TwoFactorCodeError, ConfirmationInvalidError, PasswordResetInvalidError, } from './auth.js';
 export { Link } from './navigation/Link.js';
 export { NavLink, matchActive } from './navigation/NavLink.js';
 export { navigate, back, forward, refresh, setViewTransitions, setTransitions, href, } from './navigation/navigation.js';

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "toiljs",
     "type": "module",
-    "version": "0.0.94",
+    "version": "0.0.96",
     "author": "Dacely",
     "description": "The modern React framework: a file-based React frontend and a ToilScript-compiled WebAssembly backend.",
     "repository": {

package/src/cli/create.ts

@@ -146,7 +146,7 @@ function scaffold(
         '@types/react-dom': '^19.2.3',
         eslint: '^10.2.0',
         prettier: '^3.8.1',
-        toilscript: '^0.1.37',
+        toilscript: '^0.1.55',
         typescript: '^6.0.3',
     };
     for (const dep of requiredPackages(features).sort()) {