@inflector/aura 0.1.13 → 0.1.15

package/dist/auth.d.ts

@@ -3,17 +3,26 @@ interface SessionEventsType {
     on(event: SessionEvent, callback: () => void): () => void;
     emit(event: SessionEvent): void;
 }
+declare const getTokenKey: (workspace: string) => string;
+declare const getToken: (workspace: string) => string;
+declare const setToken: (workspace: string, token: string | null) => void;
+export { getToken, setToken, getTokenKey };
 export declare const SessionEvents: SessionEventsType;
 export declare const AuraAuth: (url: string, workspace: string) => {
-    Logout: <FetchOptions extends import("better-auth").ClientFetchOption<never, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0?: import("better-auth").Prettify<{
-        query?: Record<string, any> | undefined;
-        fetchOptions?: FetchOptions | undefined;
-    }> | undefined, data_1?: FetchOptions | undefined) => Promise<import("@better-fetch/fetch").BetterFetchResponse<{
-        success: boolean;
-    }, {
-        code?: string | undefined;
-        message?: string | undefined;
-    }, FetchOptions["throw"] extends true ? true : false>>;
+    Logout: () => Promise<{
+        data: {
+            success: boolean;
+        };
+        error: null;
+    } | {
+        data: null;
+        error: {
+            code?: string | undefined | undefined;
+            message?: string | undefined | undefined;
+            status: number;
+            statusText: string;
+        };
+    }>;
     Email: {
         SignUp: <FetchOptions extends import("better-auth").ClientFetchOption<Partial<{
             name: string;
@@ -665,7 +674,7 @@ export declare const AuraAuth: (url: string, workspace: string) => {
                 statusText: string;
             };
         }>;
-        Redit: (data?: Omit<import("better-auth").Prettify<{
+        Reddit: (data?: Omit<import("better-auth").Prettify<{
             provider: (string & {}) | "github" | "apple" | "atlassian" | "cognito" | "discord" | "facebook" | "figma" | "microsoft" | "google" | "huggingface" | "slack" | "spotify" | "twitch" | "twitter" | "dropbox" | "kick" | "linear" | "linkedin" | "gitlab" | "tiktok" | "reddit" | "roblox" | "salesforce" | "vk" | "zoom" | "notion" | "kakao" | "naver" | "line" | "paybin" | "paypal" | "polar" | "vercel";
             callbackURL?: string | undefined;
             newUserCallbackURL?: string | undefined;
@@ -1238,5 +1247,4 @@ export declare const AuraAuth: (url: string, workspace: string) => {
         }, FetchOptions["throw"] extends true ? true : false>>;
     };
 };
-export {};
 //# sourceMappingURL=auth.d.ts.map

package/dist/auth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../src/auth.ts"],"names":[],"mappings":"AAKA,KAAK,YAAY,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAElD,UAAU,iBAAiB;IACzB,EAAE,CAAC,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC;IAC1D,IAAI,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI,CAAC;CACjC;AAGD,eAAO,MAAM,aAAa,EAAE,iBA+BxB,CAAC;AACL,eAAO,MAAM,QAAQ,GAAI,KAAK,MAAM,EAAE,WAAW,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBA6D3B,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;yBAQxB,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BA7DrC,CAAC;iBAChB,CAAH;;;;;;;;;;;;;;;;qBAZe,CAAC;;;;;;;;;;;;;;;;CA+IhB,CAAC"}
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../src/auth.ts"],"names":[],"mappings":"AAKA,KAAK,YAAY,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAElD,UAAU,iBAAiB;IACzB,EAAE,CAAC,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC;IAC1D,IAAI,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI,CAAC;CACjC;AAGD,QAAA,MAAM,WAAW,GAAI,WAAW,MAAM,WAAqC,CAAC;AAG5E,QAAA,MAAM,QAAQ,GAAI,WAAW,MAAM,KAAG,MAGrC,CAAC;AAEF,QAAA,MAAM,QAAQ,GAAI,WAAW,MAAM,EAAE,OAAO,MAAM,GAAG,IAAI,SAOxD,CAAC;AAGF,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,WAAW,EAAE,CAAC;AAI3C,eAAO,MAAM,aAAa,EAAE,iBAuCxB,CAAC;AACL,eAAO,MAAM,QAAQ,GAAI,KAAK,MAAM,EAAE,WAAW,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAwE3B,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;yBAQxB,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAtGpD,CAAD;iBAAe,CAAC;;;;;;;;;;;;;;;;qBAlB2B,CAAC;;;;;;;;;;;;;;;;CAmM9C,CAAC"}

package/dist/auth.js

@@ -1,8 +1,36 @@
 import { createAuthClient } from "better-auth/client";
 import { anonymousClient } from "better-auth/client/plugins";
 import { computed } from "nanostores";
+// Token storage key - unique per workspace to avoid conflicts
+const getTokenKey = (workspace) => `aura_bearer_token_${workspace}`;
+// Helper to get/set token from localStorage (with SSR safety)
+const getToken = (workspace) => {
+    if (typeof window === 'undefined')
+        return '';
+    return localStorage.getItem(getTokenKey(workspace)) || '';
+};
+const setToken = (workspace, token) => {
+    if (typeof window === 'undefined')
+        return;
+    if (token) {
+        localStorage.setItem(getTokenKey(workspace), token);
+    }
+    else {
+        localStorage.removeItem(getTokenKey(workspace));
+    }
+};
+// Export for use in other modules
+export { getToken, setToken, getTokenKey };
 // Only create once on the global object
+// Returns a no-op implementation for SSR/Node.js environments
 export const SessionEvents = (() => {
+    // Check if running in browser environment
+    if (typeof window === 'undefined') {
+        return {
+            on: () => () => { },
+            emit: () => { },
+        };
+    }
     if (window.__SessionEvents)
         return window.__SessionEvents;
     const listeners = {
@@ -39,19 +67,31 @@ export const AuraAuth = (url, workspace) => {
         baseURL: url + "/api/auth/" + workspace,
         plugins: [anonymousClient()],
         fetchOptions: {
-            credentials: "include",
+            // Use Bearer token authentication instead of cookies
+            auth: {
+                type: "Bearer",
+                token: () => getToken(workspace)
+            },
+            // Store the token from response headers on every successful request
+            onSuccess: (ctx) => {
+                const authToken = ctx.response.headers.get("set-auth-token");
+                if (authToken) {
+                    setToken(workspace, authToken);
+                }
+            }
         },
     });
     authClient.useSession.subscribe(() => {
-        const Events = window.__SessionEvents;
-        if (Events) {
-            Events.emit("change");
+        if (typeof window !== 'undefined') {
+            const Events = window.__SessionEvents;
+            if (Events) {
+                Events.emit("change");
+            }
         }
     });
     const Session = computed(authClient.useSession, (session) => {
         if (!session?.data?.user)
             return session;
-        const Events = window.__SessionEvents;
         return {
             ...session,
             data: {
@@ -88,7 +128,7 @@ export const AuraAuth = (url, workspace) => {
     };
     const OnUserLoaded = (fn) => {
         if (_initialized && User) {
-            Promise.resolve(fn());
+            Promise.resolve(fn()).catch(console.error);
         }
         else {
             _onUserLoadedCallbacks.push(fn);
@@ -96,7 +136,7 @@ export const AuraAuth = (url, workspace) => {
     };
     const OnUserNotFound = (fn) => {
         if (_initialized && !User) {
-            Promise.resolve(fn());
+            Promise.resolve(fn()).catch(console.error);
         }
         else {
             _onUserNotFoundCallbacks.push(fn);
@@ -105,7 +145,11 @@ export const AuraAuth = (url, workspace) => {
     // Initialize auth on creation
     initialize();
     return {
-        Logout: authClient.signOut,
+        Logout: async () => {
+            const result = await authClient.signOut();
+            setToken(workspace, null); // Clear token on logout
+            return result;
+        },
         Email: {
             SignUp: authClient.signUp.email,
             Login: authClient.signIn.email,
@@ -133,7 +177,7 @@ export const AuraAuth = (url, workspace) => {
                 HuggingFace: (data) => withDefaultCallback("hf", data),
                 Linkedin: (data) => withDefaultCallback("linkedin", data),
                 Microsoft: (data) => withDefaultCallback("microsoft", data),
-                Redit: (data) => withDefaultCallback("redit", data),
+                Reddit: (data) => withDefaultCallback("reddit", data),
                 Polar: (data) => withDefaultCallback("polar", data),
                 Spotify: (data) => withDefaultCallback("spotify", data),
                 Tiktok: (data) => withDefaultCallback("tiktok", data),

package/dist/database.d.ts

@@ -3,6 +3,7 @@ declare class RemoteTable<TDef extends Record<string, any>> {
     private URL;
     private Name;
     private WorkSpace;
+    private getAuthHeaders;
     constructor(url: string, name: string, workspace: string);
     Get: () => {
         where: Where<{ [K_1 in keyof TDef as K_1 extends `__${string}` ? never : TDef[K_1] extends import("@inflector/optima").ColumnBuilder<any, infer C extends import("@inflector/optima").ColumnConfig, any> ? C["notnull"] extends true ? K_1 : never : never]: TDef[K_1] extends import("@inflector/optima").ColumnBuilder<infer U, any, any> ? U : never; } & { [K_2 in keyof TDef as K_2 extends `__${string}` ? never : TDef[K_2] extends import("@inflector/optima").ColumnBuilder<any, infer C extends import("@inflector/optima").ColumnConfig, any> ? C["notnull"] extends true ? never : K_2 : never]: TDef[K_2] extends import("@inflector/optima").ColumnBuilder<infer U, any, any> ? U | null : never; } extends infer T ? { [K in keyof T]: T[K]; } : never> extends boolean ? () => {

package/dist/database.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../src/database.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAS,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAIjE,cAAM,WAAW,CAAC,IAAI,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAC9C,OAAO,CAAC,GAAG,CAAQ;IACnB,OAAO,CAAC,IAAI,CAAQ;IACpB,OAAO,CAAC,SAAS,CAAQ;gBAEb,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAMxD,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wvBAYF;IACD,MAAM;;ovBAYL;IACD,MAAM;;wvBAYL;IACD,GAAG,GAAI,QAAQ,QAAQ,CAAC,IAAI,CAAC,gvBAe5B;IACD,OAAO,GAAI,QAAQ,QAAQ,CAAC,IAAI,CAAC,EAAE,gvBAelC;IACD,MAAM,GAAI,QAAO,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;;wvBAYpC;IACD,KAAK;;4BAYJ;IACD,KAAK;;6BAYJ;IACD,SAAS,GAAI,UAAU,CAAC,CAAC,CAAC,EAAC;QAAC,MAAM,EAAC,MAAM,CAAC;QAAA,IAAI,EAAC,GAAG,GAAC,GAAG,EAAE,CAAA;KAAC,KAAK,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,EAAC;QAAC,MAAM,EAAC,MAAM,CAAC;QAAA,IAAI,EAAC,GAAG,CAAA;KAAC,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC,EAAC,QAAO,GAAG,EAAC,OAAM,OAAO,gBAa3I;CACJ;AAED,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;CAAE,EACzE,KAAK,MAAM,EACX,WAAW,MAAM,EACjB,QAAQ,CAAC,QAEe,CAAC,kCAY5B,CAAA"}
+{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../src/database.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAS,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAKjE,cAAM,WAAW,CAAC,IAAI,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAC9C,OAAO,CAAC,GAAG,CAAQ;IACnB,OAAO,CAAC,IAAI,CAAQ;IACpB,OAAO,CAAC,SAAS,CAAQ;IAEzB,OAAO,CAAC,cAAc;gBAKV,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAMxD,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wvBAYF;IACD,MAAM;;ovBAYL;IACD,MAAM;;wvBAYL;IACD,GAAG,GAAI,QAAQ,QAAQ,CAAC,IAAI,CAAC,gvBAe5B;IACD,OAAO,GAAI,QAAQ,QAAQ,CAAC,IAAI,CAAC,EAAE,gvBAelC;IACD,MAAM,GAAI,QAAQ,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;;wvBAarC;IACD,KAAK;;4BAYJ;IACD,KAAK;;6BAYJ;IACD,SAAS,GAAI,UAAU,CAAC,CAAC,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,GAAG,GAAG,GAAG,EAAE,CAAA;KAAE,KAAK,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,GAAG,CAAA;KAAE,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,GAAG,EAAE,OAAO,OAAO,gBAc7J;CACJ;AAED,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;CAAE,EACzE,KAAK,MAAM,EACX,WAAW,MAAM,EACjB,QAAQ,CAAC,QAEe,CAAC,kCAY5B,CAAA"}

package/dist/database.js

@@ -1,9 +1,14 @@
 import { createFluentBuilder } from "./fluent";
 import axios from "axios";
+import { getToken } from "./auth";
 class RemoteTable {
     URL;
     Name;
     WorkSpace;
+    getAuthHeaders() {
+        const token = getToken(this.WorkSpace);
+        return token ? { Authorization: `Bearer ${token}` } : {};
+    }
     constructor(url, name, workspace) {
         this.URL = url;
         this.Name = name;
@@ -15,7 +20,7 @@ class RemoteTable {
                 operation: 'Get',
                 settings: data,
             }, {
-                withCredentials: true
+                headers: this.getAuthHeaders()
             })).data;
         });
     };
@@ -25,7 +30,7 @@ class RemoteTable {
                 operation: 'GetOne',
                 settings: data,
             }, {
-                withCredentials: true
+                headers: this.getAuthHeaders()
             })).data;
         });
     };
@@ -35,7 +40,7 @@ class RemoteTable {
                 operation: 'Delete',
                 settings: { ...data, returning: true },
             }, {
-                withCredentials: true
+                headers: this.getAuthHeaders()
             })).data;
         });
     };
@@ -48,7 +53,7 @@ class RemoteTable {
                 },
                 data: record
             }, {
-                withCredentials: true
+                headers: this.getAuthHeaders()
             })).data;
         });
     };
@@ -61,7 +66,7 @@ class RemoteTable {
                 },
                 data: record
             }, {
-                withCredentials: true
+                headers: this.getAuthHeaders()
             })).data;
         });
     };
@@ -70,8 +75,9 @@ class RemoteTable {
             return (await axios.post(`${this.URL}/api/db/${this.WorkSpace}/${this.Name}`, {
                 operation: 'Update',
                 settings: { ...data, returning: true },
+                data: record
             }, {
-                withCredentials: true
+                headers: this.getAuthHeaders()
             })).data;
         });
     };
@@ -81,7 +87,7 @@ class RemoteTable {
                 operation: 'Count',
                 settings: data,
             }, {
-                withCredentials: true
+                headers: this.getAuthHeaders()
             })).data;
         });
     };
@@ -91,7 +97,7 @@ class RemoteTable {
                 operation: 'Exist',
                 settings: data,
             }, {
-                withCredentials: true
+                headers: this.getAuthHeaders()
             })).data;
         });
     };
@@ -101,10 +107,12 @@ class RemoteTable {
             params.push("where=" + JSON.stringify(where));
         if (init)
             params.push("init=true");
+        // Add token to query params for EventSource (doesn't support headers)
+        const token = getToken(this.WorkSpace);
+        if (token)
+            params.push("token=" + encodeURIComponent(token));
         const query = params.length ? "?" + params.join("&") : "";
-        const eventSource = new EventSource(`${this.URL}/api/db/${this.WorkSpace}/${this.Name}${query}`, {
-            withCredentials: true
-        });
+        const eventSource = new EventSource(`${this.URL}/api/db/${this.WorkSpace}/${this.Name}${query}`);
         eventSource.addEventListener(this.Name, (event) => {
             const { op, data } = JSON.parse(event.data);
             callback({ action: op, data });

package/dist/function.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"function.d.ts","sourceRoot":"","sources":["../src/function.ts"],"names":[],"mappings":"AAAA,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,CAAC,EAAE,MAAM,GAAG,GAAG,CAqGvG"}
+{"version":3,"file":"function.d.ts","sourceRoot":"","sources":["../src/function.ts"],"names":[],"mappings":"AAAA,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,CAAC,EAAE,MAAM,GAAG,GAAG,CAyHvG"}

package/dist/function.js

@@ -1,4 +1,10 @@
 export function createFunctionHandler(baseUrl, workspace, functionsFolder) {
+    // Helper to get token for Bearer auth
+    const getToken = () => {
+        if (typeof window === 'undefined')
+            return '';
+        return localStorage.getItem(`aura_bearer_token_${workspace}`) || '';
+    };
     const handler = new Proxy({}, {
         get(_, prop) {
             return createNestedProxy([prop]);
@@ -15,20 +21,22 @@ export function createFunctionHandler(baseUrl, workspace, functionsFolder) {
                 const url = [baseUrl, "api", "fn", workspace, ...path].join("/");
                 const isFormData = args != null && args.length === 1 && args[0] instanceof FormData;
                 const body = isFormData ? args[0] : JSON.stringify(args ?? {});
+                const token = getToken();
                 const headers = {
                     "Accept": "text/event-stream,application/json",
                 };
                 if (!isFormData)
                     headers["Content-Type"] = "application/json";
+                if (token)
+                    headers["Authorization"] = `Bearer ${token}`;
                 // 2. Start the fetch properly (without await)
                 const requestPromise = fetch(url, {
                     method: "POST",
                     body,
                     headers,
-                    credentials: "include",
                 });
-                // 3. Return a custom "Thenable" object immediately
-                return {
+                // 3. Return a custom "Thenable" object with full Promise interface
+                const thenable = {
                     then(onFulfilled, onRejected) {
                         requestPromise.then(async (response) => {
                             const contentType = response.headers.get("Content-Type") || "";
@@ -36,6 +44,11 @@ export function createFunctionHandler(baseUrl, workspace, functionsFolder) {
                             // SSE PATH
                             // ─────────────────────────────────────────────
                             if (contentType.includes("text/event-stream")) {
+                                if (!response.body) {
+                                    if (onRejected)
+                                        onRejected(new Error("Response body is null"));
+                                    return;
+                                }
                                 const reader = response.body.getReader();
                                 const decoder = new TextDecoder("utf-8");
                                 let buffer = "";
@@ -84,10 +97,17 @@ export function createFunctionHandler(baseUrl, workspace, functionsFolder) {
                             if (onRejected)
                                 onRejected(err);
                         });
-                        // Return 'this' to allow chaining, though strictly custom behavior
-                        return this;
+                        // Return 'this' to allow chaining
+                        return thenable;
+                    },
+                    catch(onRejected) {
+                        return thenable.then(() => { }, onRejected);
+                    },
+                    finally(onFinally) {
+                        return thenable.then((value) => { onFinally?.(); return value; }, (err) => { onFinally?.(); throw err; });
                     }
                 };
+                return thenable;
             },
         });
     }

package/dist/hooks/react.d.ts

@@ -2,7 +2,7 @@ import type { CreateAura } from '..';
 type ValueOf<T> = T[keyof T];
 export declare function useTable<TDef extends ValueOf<Awaited<ReturnType<typeof CreateAura<any, any>>>['Database']>>(table: TDef, Options?: {
     where: Parameters<Awaited<ReturnType<TDef['GetOne']>['where']>>[0];
-}): ({ [K_1 in keyof TDef as K_1 extends `__${string}` ? never : TDef[K_1] extends import("@inflector/optima").ColumnBuilder<any, infer C extends import("@inflector/optima").ColumnConfig, any> ? C["notnull"] extends true ? K_1 : never : never]: TDef[K_1] extends import("@inflector/optima").ColumnBuilder<infer U, any, any> ? U : never; } & { [K_2 in keyof TDef as K_2 extends `__${string}` ? never : TDef[K_2] extends import("@inflector/optima").ColumnBuilder<any, infer C extends import("@inflector/optima").ColumnConfig, any> ? C["notnull"] extends true ? never : K_2 : never]: TDef[K_2] extends import("@inflector/optima").ColumnBuilder<infer U, any, any> ? U | null : never; } extends infer T ? { [K in keyof T]: T[K]; } : never)[] | undefined;
+}): ({ [K_1 in keyof TDef as K_1 extends `__${string}` ? never : TDef[K_1] extends import("@inflector/optima").ColumnBuilder<any, infer C extends import("@inflector/optima").ColumnConfig, any> ? C["notnull"] extends true ? K_1 : never : never]: TDef[K_1] extends import("@inflector/optima").ColumnBuilder<infer U, any, any> ? U : never; } & { [K_2 in keyof TDef as K_2 extends `__${string}` ? never : TDef[K_2] extends import("@inflector/optima").ColumnBuilder<any, infer C extends import("@inflector/optima").ColumnConfig, any> ? C["notnull"] extends true ? never : K_2 : never]: TDef[K_2] extends import("@inflector/optima").ColumnBuilder<infer U, any, any> ? U | null : never; } extends infer T ? { [K in keyof T]: T[K]; } : never)[];
 export declare function useRecord<TDef extends ValueOf<Awaited<ReturnType<typeof CreateAura<any, any>>>['Database']>>(table: TDef, Options: {
     where: Parameters<Awaited<ReturnType<TDef['GetOne']>['where']>>[0];
 }): ({ [K_1 in keyof TDef as K_1 extends `__${string}` ? never : TDef[K_1] extends import("@inflector/optima").ColumnBuilder<any, infer C extends import("@inflector/optima").ColumnConfig, any> ? C["notnull"] extends true ? K_1 : never : never]: TDef[K_1] extends import("@inflector/optima").ColumnBuilder<infer U, any, any> ? U : never; } & { [K_2 in keyof TDef as K_2 extends `__${string}` ? never : TDef[K_2] extends import("@inflector/optima").ColumnBuilder<any, infer C extends import("@inflector/optima").ColumnConfig, any> ? C["notnull"] extends true ? never : K_2 : never]: TDef[K_2] extends import("@inflector/optima").ColumnBuilder<infer U, any, any> ? U | null : never; } extends infer T ? { [K in keyof T]: T[K]; } : never) | undefined;

package/dist/hooks/react.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../../src/hooks/react.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAS,MAAM,IAAI,CAAA;AAI3C,KAAK,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAA;AAkB5B,wBAAgB,QAAQ,CACtB,IAAI,SAAS,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,EAElF,KAAK,EAAE,IAAI,EACX,OAAO,CAAC,EAAE;IACR,KAAK,EAAE,UAAU,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;CACnE,GAyDc,4tBAAS,GAAG,SAAS,CACrC;AAED,wBAAgB,SAAS,CACvB,IAAI,SAAS,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,EAElF,KAAK,EAAE,IAAI,EACX,OAAO,EAAE;IACP,KAAK,EAAE,UAAU,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;CACnE,GAsDc,6tBAAU,SAAS,CACnC;AAED,eAAO,MAAM,OAAO,GAAI,UAAU,OAAO,CAAC,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;;;;;;;;;aAGjF,CAAA;AAED,eAAO,MAAM,UAAU,GAAI,UAAU,GAAG,QAGvC,CAAA"}
+{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../../src/hooks/react.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAS,MAAM,IAAI,CAAA;AAI3C,KAAK,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAA;AAkB5B,wBAAgB,QAAQ,CACtB,IAAI,SAAS,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,EAElF,KAAK,EAAE,IAAI,EACX,OAAO,CAAC,EAAE;IACR,KAAK,EAAE,UAAU,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;CACnE,guBAiEF;AAED,wBAAgB,SAAS,CACvB,IAAI,SAAS,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,EAElF,KAAK,EAAE,IAAI,EACX,OAAO,EAAE;IACP,KAAK,EAAE,UAAU,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;CACnE,0uBA+DF;AAED,eAAO,MAAM,OAAO,GAAI,UAAU,OAAO,CAAC,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;;;;;;;;;aAGjF,CAAA;AAED,eAAO,MAAM,UAAU,GAAI,UAAU,GAAG,QAGvC,CAAA"}

package/dist/hooks/react.js

@@ -1,5 +1,5 @@
 import { useStore } from '@nanostores/react';
-import { useEffect, useState } from 'react';
+import { useEffect, useState, useRef } from 'react';
 function deepEqual(a, b) {
     if (a === b)
         return true;
@@ -21,6 +21,12 @@ export function useTable(table, Options) {
     const [data, setData] = useState([]);
     // Dummy state to force rerun when session changes
     const [sessionVersion, setSessionVersion] = useState(0);
+    // Use ref to track where clause changes with deep comparison
+    const whereRef = useRef(Options?.where);
+    const whereString = JSON.stringify(Options?.where);
+    if (JSON.stringify(whereRef.current) !== whereString) {
+        whereRef.current = Options?.where;
+    }
     useEffect(() => {
         const handler = () => {
             setSessionVersion((v) => v + 1);
@@ -57,13 +63,19 @@ export function useTable(table, Options) {
         return () => {
             unsubscribe();
         };
-    }, [table, JSON.stringify(Options?.where), sessionVersion]); // <--- include sessionVersion here
+    }, [table, whereString, sessionVersion]); // <--- include sessionVersion here
     return data;
 }
 export function useRecord(table, Options) {
-    const [data, setData] = useState();
+    const [data, setData] = useState(undefined);
     // Dummy state to trigger rerun on session change
     const [sessionVersion, setSessionVersion] = useState(0);
+    // Use ref to track where clause changes with deep comparison
+    const whereRef = useRef(Options.where);
+    const whereString = JSON.stringify(Options.where);
+    if (JSON.stringify(whereRef.current) !== whereString) {
+        whereRef.current = Options.where;
+    }
     // Subscribe to global session changes
     useEffect(() => {
         const handler = () => {
@@ -100,7 +112,7 @@ export function useRecord(table, Options) {
             });
         }, Options.where, true);
         return () => unsubscribe();
-    }, [table, JSON.stringify(Options.where), sessionVersion]); // <--- include sessionVersion
+    }, [table, whereString, sessionVersion]); // <--- include sessionVersion
     return data;
 }
 export const useUser = (provider) => {

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAClC,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE1C,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAExC,cAAc,yBAAyB,CAAC;AACxC,cAAc,OAAO,CAAC;AACtB,cAAc,eAAe,CAAC;AAE9B,KAAK,gBAAgB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI;IACnD,MAAM,EAAE;QACJ,GAAG,EAAE,MAAM,CAAC;QACZ,SAAS,EAAE,MAAM,CAAC;QAClB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;KACtB,CAAC;IACF,MAAM,EAAE,CAAC,CAAC;CACb,CAAC;AAEF,KAAK,YAAY,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI;IAClD,QAAQ,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;IAC7C,QAAQ,EAAE,CAAC,CAAC;IACZ,OAAO,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;IACxC,IAAI,EAAE,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAC;CACrC,CAAC;AAEF,eAAO,MAAM,UAAU,GACnB,CAAC,EACD,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAE7B,QAAQ,gBAAgB,CAAC,CAAC,CAAC,KAC5B,YAAY,CAAC,CAAC,EAAE,CAAC,CAQnB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAClC,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE1C,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAExC,cAAc,yBAAyB,CAAC;AACxC,cAAc,OAAO,CAAC;AACtB,cAAc,eAAe,CAAC;AAE9B,KAAK,gBAAgB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI;IACnD,MAAM,EAAE;QACJ,GAAG,EAAE,MAAM,CAAC;QACZ,SAAS,EAAE,MAAM,CAAC;QAClB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;KACtB,CAAC;IACF,MAAM,EAAE,CAAC,CAAC;CACb,CAAC;AAEF,KAAK,YAAY,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI;IAClD,QAAQ,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;IAC7C,QAAQ,EAAE,CAAC,CAAC;IACZ,OAAO,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;IACxC,IAAI,EAAE,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAC;CACrC,CAAC;AAEF,eAAO,MAAM,UAAU,GACnB,CAAC,EACD,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAE7B,QAAQ,gBAAgB,CAAC,CAAC,CAAC,KAC5B,YAAY,CAAC,CAAC,EAAE,CAAC,CAgBnB,CAAC"}

package/dist/index.js

@@ -6,6 +6,13 @@ export * from "@inflector/optima/types";
 export * from "./lib";
 export * from "./hooks/react";
 export const CreateAura = (Config) => {
+    // Validate required config properties
+    if (!Config.config?.Url || typeof Config.config.Url !== 'string') {
+        throw new Error("CreateAura: Config.Url is required and must be a string");
+    }
+    if (!Config.config?.WorkSpace || typeof Config.config.WorkSpace !== 'string') {
+        throw new Error("CreateAura: Config.WorkSpace is required and must be a string");
+    }
     const auth = AuraAuth(Config.config.Url, Config.config.WorkSpace);
     return {
         Database: AuraDatabase(Config.config.Url, Config.config.WorkSpace, Config.Tables),

package/dist/storage.d.ts

@@ -11,16 +11,16 @@ export declare const AuraStorage: (url: string, workspace: string, userAtom: any
     Upload: (file?: File, config?: {
         openSelector?: boolean;
         allowedTypes?: string[];
-    }) => Promise<any>;
+    }) => Promise<FileAura>;
     File: (id: string) => string;
     Delete: (id: string) => Promise<any>;
-    Get: (id: string) => Promise<FileAura | undefined>;
+    Get: (id: string) => Promise<FileAura>;
     List: () => Promise<FileAura[]>;
     UploadMultiple: (files?: File[], config?: {
         openSelector?: boolean;
         allowedTypes?: string[];
-    }) => Promise<any[]>;
-    Exists: (id: string) => Promise<boolean | undefined>;
+    }) => Promise<FileAura[]>;
+    Exists: (id: string) => Promise<boolean>;
     Download: (id: string, download?: boolean, asBase64?: boolean) => Promise<{
         blob: any;
         fileName: string;

package/dist/storage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../src/storage.ts"],"names":[],"mappings":"AAAA,KAAK,QAAQ,GAAG;IACZ,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,IAAI,CAAC;CACpB,CAAC;AAIF,eAAO,MAAM,WAAW,GAAI,KAAK,MAAM,EAAE,WAAW,MAAM,EAAE,UAAU,GAAG;oBAG1D,IAAI,WACH;QAAE,YAAY,CAAC,EAAE,OAAO,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE;eAkDhD,MAAM;iBAGE,MAAM;cAYT,MAAM;;6BAwBV,IAAI,EAAE,WACN;QAAE,YAAY,CAAC,EAAE,OAAO,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE;iBAuC5C,MAAM;mBAYJ,MAAM,aAAY,OAAO,aAAmB,OAAO;;;;;CA6B/E,CAAA"}
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../src/storage.ts"],"names":[],"mappings":"AAAA,KAAK,QAAQ,GAAG;IACZ,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,IAAI,CAAC;CACpB,CAAC;AAKF,eAAO,MAAM,WAAW,GAAI,KAAK,MAAM,EAAE,WAAW,MAAM,EAAE,UAAU,GAAG;oBAQ1D,IAAI,WACH;QAAE,YAAY,CAAC,EAAE,OAAO,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,KAC5D,OAAO,CAAC,QAAQ,CAAC;eA6DL,MAAM;iBAGE,MAAM;cAYT,MAAM,KAAG,OAAO,CAAC,QAAQ,CAAC;gBAY1B,OAAO,CAAC,QAAQ,EAAE,CAAC;6BAYvB,IAAI,EAAE,WACN;QAAE,YAAY,CAAC,EAAE,OAAO,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE;iBAmD5C,MAAM,KAAG,OAAO,CAAC,OAAO,CAAC;mBAYvB,MAAM,aAAY,OAAO,aAAoB,OAAO;;;;;CA6BhF,CAAA"}

package/dist/storage.js

@@ -1,8 +1,14 @@
 import axios from "axios";
+import { getToken } from "./auth";
 export const AuraStorage = (url, workspace, userAtom) => {
+    // Helper to get auth headers for Bearer token
+    const getAuthHeaders = () => {
+        const token = getToken(workspace);
+        return token ? { Authorization: `Bearer ${token}` } : {};
+    };
     const UploadFn = async (file, config = {}) => {
         if (!userAtom.get().data)
-            return;
+            throw new Error("User not authenticated");
         // If no file is passed, or openSelector is true, open a file input dialog automatically
         if (!file || config.openSelector) {
             return new Promise(async (resolve, reject) => {
@@ -14,27 +20,37 @@ export const AuraStorage = (url, workspace, userAtom) => {
                 }
                 input.style.display = "none";
                 document.body.appendChild(input);
+                const cleanup = () => {
+                    if (document.body.contains(input)) {
+                        document.body.removeChild(input);
+                    }
+                };
                 input.onchange = async () => {
                     try {
                         const selectedFile = input.files?.[0];
                         if (!selectedFile) {
                             reject(new Error("No file selected"));
-                            document.body.removeChild(input);
+                            cleanup();
                             return;
                         }
                         const fd = new FormData();
                         fd.set("operation", "Upload");
                         fd.set("owner", userAtom.get().data.user.id);
                         fd.set("file", selectedFile);
-                        const result = (await axios.post(url + "/api/storage/" + workspace, fd)).data;
+                        const result = (await axios.post(url + "/api/storage/" + workspace, fd, { headers: getAuthHeaders() })).data;
                         resolve(result);
-                        document.body.removeChild(input);
+                        cleanup();
                     }
                     catch (e) {
                         reject(e);
-                        document.body.removeChild(input);
+                        cleanup();
                     }
                 };
+                // Handle cancel - cleanup after a delay if no file selected
+                input.addEventListener('cancel', () => {
+                    reject(new Error("File selection cancelled"));
+                    cleanup();
+                });
                 input.click();
             });
         }
@@ -44,7 +60,7 @@ export const AuraStorage = (url, workspace, userAtom) => {
             fd.set("owner", userAtom.get().data.user.id);
             fd.set("file", file);
             return (await axios.post(url + "/api/storage/" + workspace, fd, {
-                withCredentials: true
+                headers: getAuthHeaders()
             })).data;
         }
     };
@@ -55,7 +71,7 @@ export const AuraStorage = (url, workspace, userAtom) => {
         },
         Delete: async (id) => {
             if (!userAtom.get().data)
-                return;
+                throw new Error("User not authenticated");
             return (await axios.post(url + "/api/storage/" + workspace, {
                 operation: "Delete",
                 settings: {
@@ -63,12 +79,12 @@ export const AuraStorage = (url, workspace, userAtom) => {
                     Owner: userAtom.get().data.user.id
                 }
             }, {
-                withCredentials: true
+                headers: getAuthHeaders()
             })).data;
         },
         Get: async (id) => {
             if (!userAtom.get().data)
-                return;
+                throw new Error("User not authenticated");
             return (await axios.post(url + "/api/storage/" + workspace, {
                 operation: "Get",
                 settings: {
@@ -76,19 +92,19 @@ export const AuraStorage = (url, workspace, userAtom) => {
                     Owner: userAtom.get().data.user.id
                 }
             }, {
-                withCredentials: true
+                headers: getAuthHeaders()
             })).data;
         },
         List: async () => {
             if (!userAtom.get().data)
-                return [];
+                throw new Error("User not authenticated");
             return (await axios.post(url + "/api/storage/" + workspace, {
                 operation: "List",
                 settings: {
                     Owner: userAtom.get().data.user.id
                 }
             }, {
-                withCredentials: true
+                headers: getAuthHeaders()
             })).data;
         },
         UploadMultiple: async (files, config = {}) => {
@@ -104,12 +120,17 @@ export const AuraStorage = (url, workspace, userAtom) => {
                     }
                     input.style.display = "none";
                     document.body.appendChild(input);
+                    const cleanup = () => {
+                        if (document.body.contains(input)) {
+                            document.body.removeChild(input);
+                        }
+                    };
                     input.onchange = async () => {
                         const selectedFiles = Array.from(input.files ?? []);
                         try {
                             if (selectedFiles.length === 0) {
                                 reject(new Error("No files selected"));
-                                document.body.removeChild(input);
+                                cleanup();
                                 return;
                             }
                             const uploadResults = await Promise.all(selectedFiles.map(f => UploadFn(f, config)));
@@ -119,9 +140,14 @@ export const AuraStorage = (url, workspace, userAtom) => {
                             reject(e);
                         }
                         finally {
-                            document.body.removeChild(input);
+                            cleanup();
                         }
                     };
+                    // Handle cancel
+                    input.addEventListener('cancel', () => {
+                        reject(new Error("File selection cancelled"));
+                        cleanup();
+                    });
                     input.click();
                 });
             }
@@ -132,22 +158,22 @@ export const AuraStorage = (url, workspace, userAtom) => {
         },
         Exists: async (id) => {
             if (!userAtom.get().data)
-                return;
+                throw new Error("User not authenticated");
             return (await axios.post(url + "/api/storage/" + workspace, {
-                operation: "Get",
+                operation: "Exists",
                 settings: {
                     FileID: id,
                     Owner: userAtom.get().data.user.id
                 }
             }, {
-                withCredentials: true
+                headers: getAuthHeaders()
             })).data;
         },
         Download: async (id, download = true, asBase64) => {
             try {
                 const response = await axios.get(`${url}/api/storage/${workspace}/${id}?download=${download ? '1' : '0'}&base64=${asBase64 ? '1' : '0'}`, {
                     responseType: "blob",
-                    withCredentials: true
+                    headers: getAuthHeaders()
                 });
                 // Extract filename from content-disposition
                 const contentDisposition = response.headers["content-disposition"];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inflector/aura",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",