@koolbase/core 12.14.0 → 12.16.0

package/dist/cjs/auth.d.ts

@@ -1,5 +1,5 @@
 import { AuthStateListener, KoolbaseConfig, KoolbaseSession, KoolbaseUser, LinkPhoneParams, LoginParams, OtpSendResult, PhoneVerifyResult, RegisterParams, RestoreResult, KoolbaseAuditPage, KoolbaseSessionInfo, ResendVerificationResult, SendOtpParams, SignUpResult, SignInWithAppleParams, VerifyOtpParams } from './types.js';
-import type { SignInWithGoogleParams } from './types.js';
+import type { SignInWithGoogleParams, SignOutReason } from './types.js';
 export declare class KoolbaseAuth {
     private config;
     private storage;
@@ -9,6 +9,10 @@ export declare class KoolbaseAuth {
     private timeoutMs;
     private ongoingRefresh;
     private listeners;
+    /** Why the last session ended (#104); null while signed in or never signed in. */
+    private signOutReason;
+    /** The last renewal failed for want of a connection, not because the server refused it (#96). */
+    private renewalUnavailable;
     constructor(config: KoolbaseConfig);
     /**
      * Subscribe to authentication state changes. The listener fires:
@@ -82,6 +86,29 @@ export declare class KoolbaseAuth {
      * need to.
      */
     clearStoredSession(): Promise<void>;
+    /**
+     * Why the last session ended (#104): `'signed_out'` when the person signed
+     * out (or deleted their account), `'session_ended'` when it ended on its own
+     * -- revoked, past renewal, signed out on another device. null while signed
+     * in. Read it in an onAuthStateChange listener to say "You were signed out"
+     * only when they did not ask to be.
+     */
+    get lastSignOutReason(): SignOutReason | null;
+    /**
+     * A data request carrying `refused` came back unauthenticated. Renews the
+     * session and returns the token to send again with, or null when there is
+     * none -- nobody is signed in, or the server refused the renewal too, which
+     * ends the session (#96).
+     */
+    renewRejected(refused: string): Promise<string | null>;
+    /**
+     * A data request was refused as unauthenticated and renewing could not
+     * help: the session is over, so it ends here and every listener hears it.
+     * Unless the renewal failed only for want of a connection -- then the
+     * session may well be good, and signing someone out for a dropped network
+     * would be wrong (#96).
+     */
+    sessionRejected(): Promise<void>;
     private clearSessionInternal;
     restoreSession(): Promise<RestoreResult>;
     /**
@@ -164,6 +191,9 @@ export declare class KoolbaseAuth {
     private parseAppleSessionResponse;
     refresh(refreshToken?: string): Promise<KoolbaseSession>;
     private _doRefresh;
+    private readStored;
+    /** A newer session another tab stored after renewing `spent`, made current; null if none. */
+    private adoptNewer;
     logout(): Promise<boolean>;
     forgotPassword(email: string): Promise<void>;
     /**

package/dist/cjs/auth.js

@@ -11,6 +11,10 @@ class KoolbaseAuth {
         this.session = null;
         this.ongoingRefresh = null;
         this.listeners = new Set();
+        /** Why the last session ended (#104); null while signed in or never signed in. */
+        this.signOutReason = null;
+        /** The last renewal failed for want of a connection, not because the server refused it (#96). */
+        this.renewalUnavailable = false;
         this.config = config;
         this.metadata = new device_metadata_js_1.DeviceMetadata(config.appVersion);
         this.fetchFn = config.fetch ?? ((url, init) => (0, network_js_1.koolbaseFetch)(url, init));
@@ -152,6 +156,7 @@ class KoolbaseAuth {
     }
     async setSessionInternal(session) {
         this.session = session;
+        this.signOutReason = null;
         if (this.storage) {
             try {
                 await this.storage.saveSession(session);
@@ -178,9 +183,52 @@ class KoolbaseAuth {
      * need to.
      */
     async clearStoredSession() {
-        await this.clearSessionInternal();
+        await this.clearSessionInternal('session_ended');
     }
-    async clearSessionInternal() {
+    /**
+     * Why the last session ended (#104): `'signed_out'` when the person signed
+     * out (or deleted their account), `'session_ended'` when it ended on its own
+     * -- revoked, past renewal, signed out on another device. null while signed
+     * in. Read it in an onAuthStateChange listener to say "You were signed out"
+     * only when they did not ask to be.
+     */
+    get lastSignOutReason() {
+        return this.signOutReason;
+    }
+    /**
+     * A data request carrying `refused` came back unauthenticated. Renews the
+     * session and returns the token to send again with, or null when there is
+     * none -- nobody is signed in, or the server refused the renewal too, which
+     * ends the session (#96).
+     */
+    async renewRejected(refused) {
+        if (!this.session)
+            return null;
+        // Another request renewed it while this one was out.
+        if (this.session.accessToken !== refused)
+            return this.session.accessToken;
+        try {
+            return (await this.refresh()).accessToken;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * A data request was refused as unauthenticated and renewing could not
+     * help: the session is over, so it ends here and every listener hears it.
+     * Unless the renewal failed only for want of a connection -- then the
+     * session may well be good, and signing someone out for a dropped network
+     * would be wrong (#96).
+     */
+    async sessionRejected() {
+        if (!this.session || this.renewalUnavailable)
+            return;
+        await this.clearSessionInternal('session_ended');
+    }
+    async clearSessionInternal(reason = 'session_ended') {
+        if (this.session)
+            this.signOutReason = reason;
         this.session = null;
         if (this.storage) {
             try {
@@ -208,7 +256,28 @@ class KoolbaseAuth {
             : 0;
         const oneMinuteMs = 60 * 1000;
         if (expiresAt > Date.now() + oneMinuteMs) {
-            return types_js_1.RestoreResult.Restored;
+            // Valid by the clock is not valid: the session may have been signed out
+            // on another device, revoked, or the account disabled since. Ask the
+            // server before saying it is restored (#104). No answer -- offline, a
+            // timeout, a server error -- keeps the optimistic session: Offline.
+            try {
+                const res = await this.authRequest('/v1/sdk/auth/me', { method: 'GET', includeAuth: true });
+                if (res.ok) {
+                    try {
+                        await this.updateUserAndPersist(this.mapUser(await res.json()));
+                    }
+                    catch {
+                        // The session is good; a user that will not parse keeps the stored one.
+                    }
+                    return types_js_1.RestoreResult.Restored;
+                }
+                if (res.status !== 401)
+                    return types_js_1.RestoreResult.Offline;
+                // Refused: the access token is done. The refresh token decides.
+            }
+            catch {
+                return types_js_1.RestoreResult.Offline;
+            }
         }
         try {
             await this.refresh(persisted.refreshToken);
@@ -224,8 +293,8 @@ class KoolbaseAuth {
             // key or the request rather than the user's session — and deleting the
             // refresh token on that reading signs someone out with no way back.
             // Nothing reaches here with it today; it stays out so nothing does.
-            if (e instanceof auth_errors_js_1.SessionExpiredError) {
-                await this.clearSessionInternal();
+            if (isRejection(e)) {
+                await this.clearSessionInternal('session_ended');
                 return types_js_1.RestoreResult.Expired;
             }
             return types_js_1.RestoreResult.Offline;
@@ -498,17 +567,77 @@ class KoolbaseAuth {
         return promise;
     }
     async _doRefresh(refreshToken) {
-        const token = refreshToken ?? this.session?.refreshToken;
+        // The newest refresh token is the stored one: another tab of the same app
+        // may have renewed the session, and its in-memory copy here is spent.
+        const stored = refreshToken ? null : await this.readStored();
+        const token = refreshToken ?? stored?.refreshToken ?? this.session?.refreshToken;
         if (!token) {
             throw new auth_errors_js_1.SessionExpiredError();
         }
-        const res = await this.authRequest('/v1/sdk/auth/refresh', {
-            method: 'POST',
-            body: { refresh_token: token },
-        });
-        const session = await this.parseSessionResponse(res, true);
-        await this.setSessionInternal(session);
-        return session;
+        try {
+            const res = await this.authRequest('/v1/sdk/auth/refresh', {
+                method: 'POST',
+                body: { refresh_token: token },
+            });
+            const session = await this.parseSessionResponse(res, true);
+            this.renewalUnavailable = false;
+            await this.setSessionInternal(session);
+            return session;
+        }
+        catch (e) {
+            if (!isRejection(e)) {
+                // No answer, or a server error: the session may be fine. Keep it.
+                this.renewalUnavailable = true;
+                throw e;
+            }
+            this.renewalUnavailable = false;
+            // Two tabs renewing at the same moment send the same token; the
+            // server renews one and refuses the other. The winner's session is in
+            // storage: take it rather than signing out (#96).
+            const adopted = await this.adoptNewer(token);
+            if (adopted)
+                return adopted;
+            await this.clearSessionInternal('session_ended');
+            throw e;
+        }
+    }
+    async readStored() {
+        if (!this.storage)
+            return null;
+        try {
+            return await this.storage.readSession();
+        }
+        catch {
+            return null;
+        }
+    }
+    /** A newer session another tab stored after renewing `spent`, made current; null if none. */
+    async adoptNewer(spent) {
+        for (const wait of [0, 400]) {
+            if (wait)
+                await new Promise((r) => setTimeout(r, wait));
+            const stored = await this.readStored();
+            if (!stored || stored.refreshToken === spent)
+                continue;
+            const expiresAt = stored.expiresAt ? new Date(stored.expiresAt).getTime() : 0;
+            if (expiresAt > Date.now() + 60 * 1000) {
+                await this.setSessionInternal(stored);
+                return stored;
+            }
+            try {
+                const res = await this.authRequest('/v1/sdk/auth/refresh', {
+                    method: 'POST',
+                    body: { refresh_token: stored.refreshToken },
+                });
+                const session = await this.parseSessionResponse(res, true);
+                await this.setSessionInternal(session);
+                return session;
+            }
+            catch {
+                return null;
+            }
+        }
+        return null;
     }
     async logout() {
         let serverSucceeded = true;
@@ -529,7 +658,7 @@ class KoolbaseAuth {
             serverSucceeded = false;
         }
         finally {
-            await this.clearSessionInternal();
+            await this.clearSessionInternal('signed_out');
         }
         return serverSucceeded;
     }
@@ -692,7 +821,7 @@ class KoolbaseAuth {
             includeAuth: true,
         });
         await this.checkResponse(res);
-        await this.clearSessionInternal();
+        await this.clearSessionInternal('signed_out');
     }
     /**
      * Every session the signed-in user has — a "where you're signed in" list.
@@ -815,8 +944,14 @@ class KoolbaseAuth {
         try {
             return await this._ensureValidToken();
         }
-        catch {
-            return null;
+        catch (e) {
+            // Refused: the session has ended (and been cleared); go api-key-only.
+            if (isRejection(e))
+                return null;
+            // No answer: the session may be fine, so the request must not go out
+            // as a signed-out visitor (whose refusal would end it). It fails as
+            // the network failure it is, and the caller retries (#96).
+            throw e;
         }
     }
     async setSession(session) {
@@ -1064,9 +1199,9 @@ class KoolbaseAuth {
             return session.accessToken;
         }
         catch (e) {
-            if (e instanceof auth_errors_js_1.KoolbaseAuthError)
-                throw e;
-            throw new auth_errors_js_1.SessionExpiredError();
+            // A refusal stays a refusal; a network failure stays one too, rather
+            // than being reported as an ended session (#96).
+            throw e;
         }
     }
     mapUser(raw) {
@@ -1314,3 +1449,15 @@ class KoolbaseAuth {
     }
 }
 exports.KoolbaseAuth = KoolbaseAuth;
+/**
+ * Whether an error is the server refusing the session -- it ended -- rather
+ * than no answer at all (#96). Only a refusal signs anyone out.
+ */
+function isRejection(e) {
+    if (e instanceof auth_errors_js_1.SessionExpiredError || e instanceof auth_errors_js_1.TokenRevokedError || e instanceof auth_errors_js_1.UserDisabledError)
+        return true;
+    if (e instanceof auth_errors_js_1.KoolbaseAuthError) {
+        return ['invalid_refresh_token', 'token_revoked', 'account_disabled', 'mfa_session_insufficient', 'unauthenticated'].includes(e.code ?? '');
+    }
+    return false;
+}

package/dist/cjs/database.js

@@ -97,7 +97,7 @@ class KoolbaseDatabase {
         };
     }
     async request(method, path, body) {
-        const res = await (0, network_js_1.koolbaseFetch)(`${this.config.baseUrl}${path}`, {
+        const res = await (0, network_js_1.sessionFetch)(`${this.config.baseUrl}${path}`, {
             method,
             headers: await this.buildHeaders(),
             body: body ? JSON.stringify(body) : undefined,
@@ -135,7 +135,7 @@ class KoolbaseDatabase {
      * none of them clearing a rejected session. One path, two shapes of result.
      */
     async requestWithStatus(method, path, body) {
-        const res = await (0, network_js_1.koolbaseFetch)(`${this.config.baseUrl}${path}`, {
+        const res = await (0, network_js_1.sessionFetch)(`${this.config.baseUrl}${path}`, {
             method,
             headers: await this.buildHeaders(),
             body: body ? JSON.stringify(body) : undefined,

package/dist/cjs/fiscal.js

@@ -113,7 +113,7 @@ class KoolbaseFiscal {
         const controller = new AbortController();
         const timer = setTimeout(() => controller.abort(), params.timeoutMs ?? 30000);
         try {
-            const res = await (0, network_js_1.koolbaseFetch)(`${this.config.baseUrl}/v1/sdk/fiscal/submit`, {
+            const res = await (0, network_js_1.sessionFetch)(`${this.config.baseUrl}/v1/sdk/fiscal/submit`, {
                 method: 'POST',
                 headers: await this.buildHeaders(),
                 signal: controller.signal,
@@ -151,7 +151,7 @@ class KoolbaseFiscal {
                 device_id: params.deviceId,
                 client_ref: params.clientRef,
             });
-            const res = await (0, network_js_1.koolbaseFetch)(`${this.config.baseUrl}/v1/sdk/fiscal/status?${q.toString()}`, { method: 'GET', headers: await this.buildHeaders(), signal: controller.signal });
+            const res = await (0, network_js_1.sessionFetch)(`${this.config.baseUrl}/v1/sdk/fiscal/status?${q.toString()}`, { method: 'GET', headers: await this.buildHeaders(), signal: controller.signal });
             return await this.decode(res);
         }
         catch (e) {

package/dist/cjs/functions.js

@@ -14,7 +14,7 @@ class KoolbaseFunctions {
     // ─── Deploy ────────────────────────────────────────────────────────────────
     async deploy(options) {
         const runtime = options.runtime ?? types_js_1.FunctionRuntime.Deno;
-        const res = await (0, network_js_1.koolbaseFetch)(`${this.config.baseUrl}/v1/sdk/functions/deploy`, {
+        const res = await (0, network_js_1.sessionFetch)(`${this.config.baseUrl}/v1/sdk/functions/deploy`, {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
@@ -58,7 +58,7 @@ class KoolbaseFunctions {
         if (userToken) {
             headers['Authorization'] = `Bearer ${userToken}`;
         }
-        const res = await (0, network_js_1.koolbaseFetch)(`${this.config.baseUrl}/v1/sdk/functions/${name}`, {
+        const res = await (0, network_js_1.sessionFetch)(`${this.config.baseUrl}/v1/sdk/functions/${name}`, {
             method: 'POST',
             headers,
             body: JSON.stringify({ body: body ?? {} }),

package/dist/cjs/index.d.ts

@@ -20,6 +20,9 @@ export { KoolbaseRealtime } from './realtime.js';
 export { KoolbaseConnectivity } from './connectivity.js';
 export type { ConnectivityState } from './connectivity.js';
 export { KoolbaseStorage } from './storage.js';
+export { KoolbaseUploadTask } from './storage-transfer.js';
+export type { KoolbaseUploadProgress, KoolbaseUploadState } from './storage-transfer.js';
+export type { KoolbaseFileInfo, KoolbaseFilePage, KoolbaseFileSort, ListFilesOptions } from './storage-files.js';
 export { KoolbaseAnalytics, disabledAnalytics } from './analytics.js';
 export { KoolbaseFiscal, KoolbaseFiscalError, decodeFiscalResponse, isFiscalized, isPending } from './fiscal.js';
 export type { FiscalIntentResult, FiscalStatus } from './fiscal.js';

package/dist/cjs/index.js

@@ -19,7 +19,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.memoryPlatform = exports.getPlatform = exports.setPlatform = exports.RestoreResult = exports.koolbaseSdkVersion = exports.getOrCreateDeviceId = exports.KoolbaseMessaging = exports.isPending = exports.isFiscalized = exports.decodeFiscalResponse = exports.KoolbaseFiscalError = exports.KoolbaseFiscal = exports.disabledAnalytics = exports.KoolbaseAnalytics = exports.KoolbaseStorage = exports.KoolbaseConnectivity = exports.KoolbaseRealtime = exports.KoolbaseFunctions = exports.KoolbaseFlags = exports.initialRecordState = exports.KoolbaseRecordController = exports.initialCollectionState = exports.collectionQueryKey = exports.KoolbaseCollectionController = exports.KoolbaseDatabase = exports.KoolbaseAuth = void 0;
+exports.memoryPlatform = exports.getPlatform = exports.setPlatform = exports.RestoreResult = exports.koolbaseSdkVersion = exports.getOrCreateDeviceId = exports.KoolbaseMessaging = exports.isPending = exports.isFiscalized = exports.decodeFiscalResponse = exports.KoolbaseFiscalError = exports.KoolbaseFiscal = exports.disabledAnalytics = exports.KoolbaseAnalytics = exports.KoolbaseUploadTask = exports.KoolbaseStorage = exports.KoolbaseConnectivity = exports.KoolbaseRealtime = exports.KoolbaseFunctions = exports.KoolbaseFlags = exports.initialRecordState = exports.KoolbaseRecordController = exports.initialCollectionState = exports.collectionQueryKey = exports.KoolbaseCollectionController = exports.KoolbaseDatabase = exports.KoolbaseAuth = void 0;
 __exportStar(require("./types.js"), exports);
 __exportStar(require("./errors.js"), exports);
 __exportStar(require("./network.js"), exports);
@@ -51,6 +51,8 @@ var connectivity_js_1 = require("./connectivity.js");
 Object.defineProperty(exports, "KoolbaseConnectivity", { enumerable: true, get: function () { return connectivity_js_1.KoolbaseConnectivity; } });
 var storage_js_1 = require("./storage.js");
 Object.defineProperty(exports, "KoolbaseStorage", { enumerable: true, get: function () { return storage_js_1.KoolbaseStorage; } });
+var storage_transfer_js_1 = require("./storage-transfer.js");
+Object.defineProperty(exports, "KoolbaseUploadTask", { enumerable: true, get: function () { return storage_transfer_js_1.KoolbaseUploadTask; } });
 var analytics_js_1 = require("./analytics.js");
 Object.defineProperty(exports, "KoolbaseAnalytics", { enumerable: true, get: function () { return analytics_js_1.KoolbaseAnalytics; } });
 Object.defineProperty(exports, "disabledAnalytics", { enumerable: true, get: function () { return analytics_js_1.disabledAnalytics; } });

package/dist/cjs/network.d.ts

@@ -19,3 +19,17 @@ export declare class KoolbaseNetworkError extends TypeError {
 }
 /** fetch, with network failures turned into a KoolbaseNetworkError. */
 export declare function koolbaseFetch(input: string, init?: RequestInit): Promise<Response>;
+type Renewal = (refusedToken: string) => Promise<string | null>;
+/** Installed by Koolbase.initialize: renews the session a request was refused with. */
+export declare function setSessionRenewal(fn: Renewal | null): void;
+/**
+ * koolbaseFetch for a data request. A request refused as unauthenticated
+ * (401) while carrying the signed-in person's token is the session needing
+ * renewal, not ending: the access token expired early, the clock is off, or
+ * another tab renewed it. The session is renewed once and the request sent
+ * again with the new token, so the caller never sees the first refusal.
+ * Only when renewal is refused does the 401 reach the caller, and with it the
+ * client's onSessionExpired, which ends the session.
+ */
+export declare function sessionFetch(input: string, init?: RequestInit): Promise<Response>;
+export {};

package/dist/cjs/network.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KoolbaseNetworkError = void 0;
 exports.koolbaseFetch = koolbaseFetch;
+exports.setSessionRenewal = setSessionRenewal;
+exports.sessionFetch = sessionFetch;
 /**
  * Network failures, made actionable.
  *
@@ -52,3 +54,61 @@ async function koolbaseFetch(input, init) {
         throw new KoolbaseNetworkError(input, e);
     }
 }
+let renewal = null;
+/** Installed by Koolbase.initialize: renews the session a request was refused with. */
+function setSessionRenewal(fn) {
+    renewal = fn;
+}
+function headerOf(headers, name) {
+    if (!headers)
+        return undefined;
+    if (typeof headers.get === 'function')
+        return headers.get(name) ?? undefined;
+    if (Array.isArray(headers))
+        return headers.find(([k]) => k.toLowerCase() === name.toLowerCase())?.[1];
+    const rec = headers;
+    const key = Object.keys(rec).find((k) => k.toLowerCase() === name.toLowerCase());
+    return key ? rec[key] : undefined;
+}
+function withHeader(headers, name, value) {
+    const out = {};
+    if (headers && typeof headers.forEach === 'function' && !Array.isArray(headers)) {
+        headers.forEach((v, k) => { out[k] = v; });
+    }
+    else if (Array.isArray(headers)) {
+        for (const [k, v] of headers)
+            out[k] = v;
+    }
+    else if (headers) {
+        Object.assign(out, headers);
+    }
+    for (const k of Object.keys(out))
+        if (k.toLowerCase() === name.toLowerCase())
+            delete out[k];
+    out[name] = value;
+    return out;
+}
+/**
+ * koolbaseFetch for a data request. A request refused as unauthenticated
+ * (401) while carrying the signed-in person's token is the session needing
+ * renewal, not ending: the access token expired early, the clock is off, or
+ * another tab renewed it. The session is renewed once and the request sent
+ * again with the new token, so the caller never sees the first refusal.
+ * Only when renewal is refused does the 401 reach the caller, and with it the
+ * client's onSessionExpired, which ends the session.
+ */
+async function sessionFetch(input, init) {
+    const res = await koolbaseFetch(input, init);
+    if (res.status !== 401 || !renewal)
+        return res;
+    const auth = headerOf(init?.headers, 'Authorization');
+    if (!auth || !auth.startsWith('Bearer '))
+        return res;
+    // Only a body that can be sent twice. Data requests send JSON text.
+    if (init?.body !== undefined && init.body !== null && typeof init.body !== 'string')
+        return res;
+    const fresh = await renewal(auth.slice('Bearer '.length));
+    if (!fresh)
+        return res;
+    return koolbaseFetch(input, { ...init, headers: withHeader(init?.headers, 'Authorization', `Bearer ${fresh}`) });
+}

package/dist/cjs/storage-errors.d.ts

@@ -187,6 +187,45 @@ export declare class KoolbaseStorageMetadataInvalidError extends KoolbaseStorage
     detail?: string;
     constructor(message?: string, detail?: string);
 }
+/**
+ * An upload that was cancelled -- by `KoolbaseUploadTask.cancel()` or the
+ * upload's `signal` -- before the server began checking it. Nothing was
+ * stored. Code: `upload_cancelled`.
+ */
+export declare class KoolbaseUploadCancelledError extends KoolbaseStorageError {
+    constructor(message?: string);
+}
+/**
+ * The confirm named an upload the server does not have: it expired, was
+ * confirmed already, or belongs to someone else. Upload the file again.
+ * Code: `upload_not_found`.
+ */
+export declare class KoolbaseUploadNotFoundError extends KoolbaseStorageError {
+    constructor(message?: string);
+}
+/**
+ * The bucket is busy with other changes (a large move, many uploads at
+ * once). Nothing was changed; retry shortly. Code: `bucket_busy`.
+ */
+export declare class KoolbaseStorageBusyError extends KoolbaseStorageError {
+    constructor(message?: string);
+}
+/**
+ * A listing's cursor was not one this listing issued -- made up, or from a
+ * listing with another sort or order. Start again from the first page.
+ * Code: `invalid_cursor`.
+ */
+export declare class KoolbaseStorageInvalidCursorError extends KoolbaseStorageError {
+    constructor(message?: string);
+}
+/**
+ * The bucket's rules allow this only to someone signed in, and nobody is.
+ * Not a session that ended: the SDK's session is left alone. Code:
+ * `sign_in_required`.
+ */
+export declare class KoolbaseStorageSignInRequiredError extends KoolbaseStorageError {
+    constructor(message?: string);
+}
 /**
  * Maps a non-2xx storage-layer response to a typed
  * {@link KoolbaseStorageError}, preferring the server's stable `code` and

package/dist/cjs/storage-errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.KoolbaseStorageMetadataInvalidError = exports.KoolbaseStorageMimeTypeError = exports.KoolbaseStorageFileTooLargeError = exports.KoolbaseStorageQuotaError = exports.KoolbaseCapBelowUsageError = exports.KoolbaseUploadExpiredError = exports.KoolbaseUploadURLFailedError = exports.KoolbaseStoragePermissionError = exports.KoolbaseStorageValidationError = exports.KoolbaseStorageNotFoundError = exports.KoolbaseStorageConflictError = exports.KoolbaseStorageProjectIdentityError = exports.KoolbaseStorageError = void 0;
+exports.KoolbaseStorageSignInRequiredError = exports.KoolbaseStorageInvalidCursorError = exports.KoolbaseStorageBusyError = exports.KoolbaseUploadNotFoundError = exports.KoolbaseUploadCancelledError = exports.KoolbaseStorageMetadataInvalidError = exports.KoolbaseStorageMimeTypeError = exports.KoolbaseStorageFileTooLargeError = exports.KoolbaseStorageQuotaError = exports.KoolbaseCapBelowUsageError = exports.KoolbaseUploadExpiredError = exports.KoolbaseUploadURLFailedError = exports.KoolbaseStoragePermissionError = exports.KoolbaseStorageValidationError = exports.KoolbaseStorageNotFoundError = exports.KoolbaseStorageConflictError = exports.KoolbaseStorageProjectIdentityError = exports.KoolbaseStorageError = void 0;
 exports.koolbaseStorageError = koolbaseStorageError;
 exports.koolbaseStorageErrorFromResponse = koolbaseStorageErrorFromResponse;
 const errors_js_1 = require("./errors.js");
@@ -252,6 +252,70 @@ class KoolbaseStorageMetadataInvalidError extends KoolbaseStorageError {
     }
 }
 exports.KoolbaseStorageMetadataInvalidError = KoolbaseStorageMetadataInvalidError;
+/**
+ * An upload that was cancelled -- by `KoolbaseUploadTask.cancel()` or the
+ * upload's `signal` -- before the server began checking it. Nothing was
+ * stored. Code: `upload_cancelled`.
+ */
+class KoolbaseUploadCancelledError extends KoolbaseStorageError {
+    constructor(message) {
+        super(message ?? 'The upload was cancelled', 'upload_cancelled');
+        this.name = 'KoolbaseUploadCancelledError';
+        Object.setPrototypeOf(this, KoolbaseUploadCancelledError.prototype);
+    }
+}
+exports.KoolbaseUploadCancelledError = KoolbaseUploadCancelledError;
+/**
+ * The confirm named an upload the server does not have: it expired, was
+ * confirmed already, or belongs to someone else. Upload the file again.
+ * Code: `upload_not_found`.
+ */
+class KoolbaseUploadNotFoundError extends KoolbaseStorageError {
+    constructor(message) {
+        super(message ?? 'This upload was not found -- please upload the file again', 'upload_not_found');
+        this.name = 'KoolbaseUploadNotFoundError';
+        Object.setPrototypeOf(this, KoolbaseUploadNotFoundError.prototype);
+    }
+}
+exports.KoolbaseUploadNotFoundError = KoolbaseUploadNotFoundError;
+/**
+ * The bucket is busy with other changes (a large move, many uploads at
+ * once). Nothing was changed; retry shortly. Code: `bucket_busy`.
+ */
+class KoolbaseStorageBusyError extends KoolbaseStorageError {
+    constructor(message) {
+        super(message ?? 'The bucket is busy -- try again shortly', 'bucket_busy');
+        this.name = 'KoolbaseStorageBusyError';
+        Object.setPrototypeOf(this, KoolbaseStorageBusyError.prototype);
+    }
+}
+exports.KoolbaseStorageBusyError = KoolbaseStorageBusyError;
+/**
+ * A listing's cursor was not one this listing issued -- made up, or from a
+ * listing with another sort or order. Start again from the first page.
+ * Code: `invalid_cursor`.
+ */
+class KoolbaseStorageInvalidCursorError extends KoolbaseStorageError {
+    constructor(message) {
+        super(message ?? 'The cursor is not valid for this listing', 'invalid_cursor');
+        this.name = 'KoolbaseStorageInvalidCursorError';
+        Object.setPrototypeOf(this, KoolbaseStorageInvalidCursorError.prototype);
+    }
+}
+exports.KoolbaseStorageInvalidCursorError = KoolbaseStorageInvalidCursorError;
+/**
+ * The bucket's rules allow this only to someone signed in, and nobody is.
+ * Not a session that ended: the SDK's session is left alone. Code:
+ * `sign_in_required`.
+ */
+class KoolbaseStorageSignInRequiredError extends KoolbaseStorageError {
+    constructor(message) {
+        super(message ?? 'Sign in to do this', 'sign_in_required');
+        this.name = 'KoolbaseStorageSignInRequiredError';
+        Object.setPrototypeOf(this, KoolbaseStorageSignInRequiredError.prototype);
+    }
+}
+exports.KoolbaseStorageSignInRequiredError = KoolbaseStorageSignInRequiredError;
 /**
  * Maps a non-2xx storage-layer response to a typed
  * {@link KoolbaseStorageError}, preferring the server's stable `code` and
@@ -289,6 +353,16 @@ function koolbaseStorageError(status, body, fallbackMessage = 'Storage request f
             return new KoolbaseStorageMetadataInvalidError(message, body?.detail);
         case 'upload_url_failed':
             return new KoolbaseUploadURLFailedError(message);
+        case 'upload_not_found':
+            return new KoolbaseUploadNotFoundError(message);
+        case 'bucket_busy':
+            return new KoolbaseStorageBusyError(message);
+        case 'invalid_cursor':
+            return new KoolbaseStorageInvalidCursorError(message);
+        case 'sign_in_required':
+            return new KoolbaseStorageSignInRequiredError(message);
+        case 'not_allowed':
+            return new KoolbaseStoragePermissionError(message);
     }
     // ─── status fallback (pre-code servers or uncoded paths) ───
     switch (status) {