@base44-preview/sdk 0.8.36-pr.219.4b81d03 → 0.8.37-pr.212.00d8065

package/dist/client.js

@@ -12,6 +12,7 @@ import { createAppLogsModule } from "./modules/app-logs.js";
 import { createUsersModule } from "./modules/users.js";
 import { RoomsSocket } from "./utils/socket-utils.js";
 import { createAnalyticsModule } from "./modules/analytics.js";
+import { createRealtimeModule } from "./modules/realtime.js";
 /**
  * Creates a Base44 client.
  *
@@ -51,9 +52,27 @@ import { createAnalyticsModule } from "./modules/analytics.js";
  */
 export function createClient(config) {
     var _a, _b;
-    const { serverUrl = "https://base44.app", appId, token, serviceToken, requiresAuth = false, appBaseUrl, options, functionsVersion, headers: optionalHeaders, } = config;
+    const { serverUrl = "https://base44.app", appId, token, serviceToken, requiresAuth = false, appBaseUrl, options, functionsVersion, headers: optionalHeaders, dispatcherWsUrl, webSocketImpl, } = config;
     // Normalize appBaseUrl to always be a string (empty if not provided or invalid)
     const normalizedAppBaseUrl = typeof appBaseUrl === "string" ? appBaseUrl : "";
+    // Derive the dispatcher WebSocket URL if not explicitly provided. Default to
+    // the app's OWN origin (the app URL proxies /parties to the backend) so the
+    // socket is same-origin with the running app, not the API host: prefer an
+    // explicit appBaseUrl, then the browser origin, then fall back to serverUrl
+    // (Node/SSR, where there's no window). Convert https:// → wss:// (http → ws)
+    // and strip the trailing slash.
+    const resolvedDispatcherWsUrl = (() => {
+        var _a, _b;
+        if (dispatcherWsUrl)
+            return dispatcherWsUrl.replace(/\/$/, "");
+        const appOrigin = normalizedAppBaseUrl ||
+            // React Native has a bare `window` with no `location`, so guard both.
+            (typeof window !== "undefined" ? (_b = (_a = window.location) === null || _a === void 0 ? void 0 : _a.origin) !== null && _b !== void 0 ? _b : "" : "");
+        return (appOrigin || serverUrl)
+            .replace(/\/$/, "")
+            .replace(/^https:\/\//, "wss://")
+            .replace(/^http:\/\//, "ws://");
+    })();
     const socketConfig = {
         serverUrl,
         mountPath: "/ws-user-apps/socket.io/",
@@ -160,6 +179,22 @@ export function createClient(config) {
             appId,
             userAuthModule,
         }),
+        realtime: createRealtimeModule({
+            appId,
+            dispatcherWsUrl: resolvedDispatcherWsUrl,
+            webSocketImpl,
+            getToken: async (handlerName, instanceId, connId) => {
+                // axiosClient interceptors unwrap response.data, so the result is the body directly.
+                // conn_id rides inside the signed token (not a WS query param) so it survives
+                // proxies that strip params; the dispatcher forwards it as the handler's conn.id.
+                // Base44-Functions-Version rides along (like function calls) so live apps get
+                // tokens for the *published* realtime script and previews get the draft.
+                const data = await axiosClient.post(`/apps/${appId}/realtime-token`, { handler_name: handlerName, instance_id: instanceId, conn_id: connId }, functionsVersion
+                    ? { headers: { "Base44-Functions-Version": functionsVersion } }
+                    : undefined);
+                return data.token;
+            },
+        }),
         cleanup: () => {
             userModules.analytics.cleanup();
             if (socket) {

package/dist/client.types.d.ts

@@ -8,6 +8,7 @@ import type { AgentsModule } from "./modules/agents.types.js";
 import type { AiGatewayModule } from "./modules/ai-gateway.types.js";
 import type { AppLogsModule } from "./modules/app-logs.types.js";
 import type { AnalyticsModule } from "./modules/analytics.types.js";
+import type { RealtimeModule } from "./modules/realtime.types.js";
 /**
  * Options for creating a Base44 client.
  */
@@ -73,6 +74,28 @@ export interface CreateClientConfig {
      * Additional client options.
      */
     options?: CreateClientOptions;
+    /**
+     * Base WebSocket URL for the Cloudflare Durable Object dispatcher.
+     *
+     * Defaults to the app's own origin (`appBaseUrl`, else the browser's
+     * `window.location.origin`, else `serverUrl`) with `https://` replaced by
+     * `wss://` (or `http://` by `ws://`) — so the realtime socket is same-origin
+     * with the running app, which proxies `/parties` to the backend.
+     * Override when the dispatcher lives at a different host than the app.
+     */
+    dispatcherWsUrl?: string;
+    /**
+     * WebSocket implementation for realtime subscriptions in environments
+     * without a global `WebSocket` (Node.js < 22). Browsers and Node ≥ 22
+     * don't need this.
+     *
+     * @example
+     * ```typescript
+     * import WS from "ws";
+     * const base44 = createClient({ appId, webSocketImpl: WS });
+     * ```
+     */
+    webSocketImpl?: unknown;
 }
 /**
  * The Base44 client instance.
@@ -88,6 +111,8 @@ export interface Base44Client {
     analytics: AnalyticsModule;
     /** {@link AppLogsModule | App logs module} for tracking app usage. */
     appLogs: AppLogsModule;
+    /** {@link RealtimeModule | Realtime module} for subscribing to and sending messages via Cloudflare Durable Object-backed RealtimeHandlers. */
+    realtime: RealtimeModule;
     /** {@link AuthModule | Auth module} for user authentication and management. */
     auth: AuthModule;
     /** {@link UserConnectorsModule | Connectors module} for app-user OAuth flows. */

package/dist/index.d.ts

@@ -11,7 +11,9 @@ export type { FunctionsModule, FunctionName, FunctionNameRegistry, } from "./mod
 export type { AgentsModule, AgentName, AgentNameRegistry, AgentConversation, AgentMessage, AgentMessageReasoning, AgentMessageToolCall, AgentMessageUsage, AgentMessageCustomContext, AgentMessageMetadata, CreateConversationParams, } from "./modules/agents.types.js";
 export type { AiGatewayModule, AiGatewayConnection, } from "./modules/ai-gateway.types.js";
 export type { AppLogsModule } from "./modules/app-logs.types.js";
+export type { RealtimeModule, RealtimeHandlerClient, RealtimeHandlerNameRegistry, RealtimeHandlerRegistry, } from "./modules/realtime.types.js";
 export type { SsoModule, SsoAccessTokenResponse } from "./modules/sso.types.js";
+export { RealtimeHandler, type Conn } from "./realtime-handler.js";
 export type { ConnectorsModule, UserConnectorsModule, } from "./modules/connectors.types.js";
 export type { CustomIntegrationsModule, CustomIntegrationCallParams, CustomIntegrationCallResponse, } from "./modules/custom-integrations.types.js";
 export type { GetAccessTokenOptions, SaveAccessTokenOptions, RemoveAccessTokenOptions, GetLoginUrlOptions, } from "./utils/auth-utils.types.js";

package/dist/index.js

@@ -3,3 +3,4 @@ import { Base44Error } from "./utils/axios-client.js";
 import { getAccessToken, saveAccessToken, removeAccessToken, getLoginUrl, } from "./utils/auth-utils.js";
 export { createClient, createClientFromRequest, Base44Error, getAccessToken, saveAccessToken, removeAccessToken, getLoginUrl, };
 export * from "./types.js";
+export { RealtimeHandler } from "./realtime-handler.js";

package/dist/modules/analytics.js

@@ -1,5 +1,5 @@
 import { getSharedInstance } from "../utils/sharedInstance.js";
-import { generateUuid } from "../utils/common.js";
+import { generateUuid, isReactNative } from "../utils/common.js";
 export const USER_HEARTBEAT_EVENT_NAME = "__user_heartbeat_event__";
 export const ANALYTICS_INITIALIZATION_EVENT_NAME = "__initialization_event__";
 export const ANALYTICS_SESSION_DURATION_EVENT_NAME = "__session_duration_event__";
@@ -34,7 +34,11 @@ export const createAnalyticsModule = ({ axiosClient, serverUrl, appId, userAuthM
     var _a;
     // prevent overflow of events //
     const { maxQueueSize, throttleTime, batchSize } = analyticsSharedState.config;
-    if (!((_a = analyticsSharedState.config) === null || _a === void 0 ? void 0 : _a.enabled)) {
+    // Disable analytics on React Native. It defines `window` but not `document`,
+    // so the per-callsite `typeof window` guards below aren't enough to keep it
+    // from touching `document` (e.g. `document.referrer` on init). Node/SSR is
+    // still handled by those `window` guards, so this doesn't affect it.
+    if (!((_a = analyticsSharedState.config) === null || _a === void 0 ? void 0 : _a.enabled) || isReactNative) {
         return {
             track: () => { },
             cleanup: () => { },
@@ -242,7 +246,10 @@ async function getSessionContext(userAuthModule) {
     return analyticsSharedState.sessionContext;
 }
 export function getAnalyticsConfigFromUrlParams() {
-    if (typeof window === "undefined")
+    // `window.location` is absent on React Native. This runs at module load (via
+    // the shared-state factory), so an unguarded `window.location.search` would
+    // throw on import there.
+    if (typeof window === "undefined" || !window.location)
         return undefined;
     const urlParams = new URLSearchParams(window.location.search);
     const analyticsEnable = urlParams.get(ANALYTICS_CONFIG_ENABLE_URL_PARAM_KEY);

package/dist/modules/realtime.d.ts

@@ -0,0 +1,21 @@
+export declare function createRealtimeModule(config: {
+    appId: string;
+    getToken(handlerName: string, instanceId: string, connId: string): Promise<string>;
+    dispatcherWsUrl: string;
+    /** WebSocket implementation for runtimes without a global one (Node < 22). */
+    webSocketImpl?: unknown;
+}): Record<string, RealtimeHandler>;
+/** Handle for an active realtime subscription. */
+interface RealtimeSubscription {
+    /** This connection's id — the same value the handler receives as `conn.id`. */
+    id: string;
+    /** Close the subscription and its underlying socket. */
+    unsubscribe(): void;
+}
+interface RealtimeHandler {
+    subscribe(instanceId: string, callback: (data: unknown) => void, options?: {
+        id?: string;
+    }): RealtimeSubscription;
+    send(instanceId: string, data: unknown): void;
+}
+export {};

package/dist/modules/realtime.js

@@ -0,0 +1,89 @@
+import PartySocket from "partysocket";
+// Module-level map: "HandlerName:instanceId" → active socket
+const activeSockets = new Map();
+function socketKey(handlerName, instanceId) {
+    return `${handlerName}:${instanceId}`;
+}
+export function createRealtimeModule(config) {
+    return new Proxy({}, {
+        get(_, handlerName) {
+            return {
+                subscribe(instanceId, callback, options) {
+                    var _a, _b;
+                    const key = socketKey(handlerName, instanceId);
+                    // close existing if any
+                    (_a = activeSockets.get(key)) === null || _a === void 0 ? void 0 : _a.close();
+                    // Connection id: caller-supplied (stable — reuse across reconnects/tabs as
+                    // you see fit) or auto-generated per subscription. It travels INSIDE the
+                    // signed realtime token (never as a WS query param, which proxies strip);
+                    // the dispatcher forwards the verified claim as partyserver's _pk, so the
+                    // handler sees this exact value as conn.id. Reconnects re-mint the token
+                    // with the same id, so conn.id is stable across reconnects.
+                    const connId = (_b = options === null || options === void 0 ? void 0 : options.id) !== null && _b !== void 0 ? _b : crypto.randomUUID();
+                    // query as async fn: called on every (re)connect, fetches a fresh token each time
+                    const ws = new PartySocket({
+                        host: config.dispatcherWsUrl,
+                        party: handlerName,
+                        room: instanceId,
+                        ...(config.webSocketImpl ? { WebSocket: config.webSocketImpl } : {}),
+                        query: () => config.getToken(handlerName, instanceId, connId).then((token) => ({ token })),
+                    });
+                    activeSockets.set(key, ws);
+                    // Heartbeat / half-open detection. PartySocket only reconnects on a
+                    // browser close/error event, so a silently-dead connection (TCP alive,
+                    // no data — common behind proxies/LBs) hangs until the OS idle timeout
+                    // (~60s). We ping periodically and force a reconnect if nothing comes
+                    // back within DEAD_MS, cutting detection from ~60s to a few seconds.
+                    const PING_MS = 1000;
+                    const DEAD_MS = 3000;
+                    let lastMsg = Date.now();
+                    const bumpAlive = () => { lastMsg = Date.now(); };
+                    ws.addEventListener("open", bumpAlive);
+                    ws.addEventListener("message", (ev) => {
+                        bumpAlive();
+                        let data;
+                        try {
+                            data = JSON.parse(ev.data);
+                        }
+                        catch (_a) {
+                            return; // ignore malformed
+                        }
+                        // Swallow platform messages — never surface them to the app.
+                        const msgType = data && typeof data === "object" ? data.type : undefined;
+                        if (msgType === "__pong")
+                            return;
+                        callback(data);
+                    });
+                    const heartbeat = setInterval(() => {
+                        if (Date.now() - lastMsg > DEAD_MS) {
+                            bumpAlive(); // avoid a reconnect storm while the new socket comes up
+                            ws.reconnect();
+                            return;
+                        }
+                        try {
+                            ws.send(JSON.stringify({ type: "__ping" }));
+                        }
+                        catch (_a) {
+                            // socket not open; the watchdog above will force a reconnect
+                        }
+                    }, PING_MS);
+                    return {
+                        id: connId, // the connection id (same value the handler sees as conn.id)
+                        unsubscribe() {
+                            clearInterval(heartbeat);
+                            activeSockets.delete(key);
+                            ws.close();
+                        },
+                    };
+                },
+                send(instanceId, data) {
+                    const key = socketKey(handlerName, instanceId);
+                    const ws = activeSockets.get(key);
+                    if (!ws)
+                        throw new Error(`No active subscription for ${handlerName}:${instanceId}`);
+                    ws.send(JSON.stringify(data));
+                },
+            };
+        },
+    });
+}

package/dist/modules/realtime.types.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Extend this interface to add typed `subscribe` callbacks and `send` payloads
+ * for your deployed RealtimeHandlers.
+ *
+ * This is separate from {@link RealtimeHandlerNameRegistry} (which is auto-generated
+ * by `base44 types generate`), so there are no conflicts.
+ *
+ * @example
+ * ```typescript
+ * declare module "@base44/sdk" {
+ *   interface RealtimeHandlerRegistry {
+ *     ChatRoom: {
+ *       toClient: { type: "joined" | "left" | "message"; userId?: string; from?: string; text?: string };
+ *       toServer: { type: "message"; text: string };
+ *     };
+ *   }
+ * }
+ * ```
+ */
+export interface RealtimeHandlerRegistry {
+}
+/**
+ * Auto-populated by `base44 types generate` with the names of your deployed handlers.
+ * Do not edit this interface manually — use {@link RealtimeHandlerRegistry} for message types.
+ */
+export interface RealtimeHandlerNameRegistry {
+}
+type AllHandlerNames = keyof RealtimeHandlerRegistry | keyof RealtimeHandlerNameRegistry;
+type ToClientFor<N extends string> = N extends keyof RealtimeHandlerRegistry ? RealtimeHandlerRegistry[N] extends {
+    toClient: infer I;
+} ? I : unknown : unknown;
+type ToServerFor<N extends string> = N extends keyof RealtimeHandlerRegistry ? RealtimeHandlerRegistry[N] extends {
+    toServer: infer O;
+} ? O : unknown : unknown;
+/**
+ * Client for a single named RealtimeHandler.
+ * Typed automatically when the handler is registered in {@link RealtimeHandlerRegistry}.
+ */
+export interface RealtimeHandlerClient<N extends string = string> {
+    /**
+     * Open a WebSocket subscription. Returns a {@link RealtimeSubscription} with the
+     * connection `id` (same value the handler sees as `conn.id`) and an `unsubscribe()` method.
+     *
+     * Pass `options.id` to control the connection id (e.g. a stable per-tab id so a
+     * reconnect reuses the same server-side connection); omit it for an auto-generated
+     * per-connection id.
+     */
+    subscribe(instanceId: string, callback: (data: ToClientFor<N>) => void, options?: {
+        id?: string;
+    }): RealtimeSubscription;
+    /** Send a message over the open socket. Throws if not subscribed. */
+    send(instanceId: string, data: ToServerFor<N>): void;
+}
+/** Handle for an active realtime subscription. */
+export interface RealtimeSubscription {
+    /** This connection's id — the same value the handler receives as `conn.id`. */
+    id: string;
+    /** Close the subscription and its underlying socket. */
+    unsubscribe(): void;
+}
+/**
+ * The realtime module provides access to Cloudflare Durable Object-backed
+ * RealtimeHandlers deployed by the Base44 platform.
+ *
+ * Handler names are accessed as dynamic properties on this module:
+ * ```typescript
+ * const sub = await base44.realtime.MyHandler.subscribe("room-1", (msg) => {
+ *   console.log(msg); // typed if MyHandler is in RealtimeHandlerRegistry
+ * });
+ * const { id, unsubscribe } = sub;
+ * unsubscribe();
+ * ```
+ */
+export type RealtimeModule = {
+    [K in AllHandlerNames]: K extends keyof RealtimeHandlerRegistry ? RealtimeHandlerClient<string & K> : RealtimeHandlerClient;
+} & Record<string, RealtimeHandlerClient>;
+export {};

package/dist/modules/realtime.types.js

@@ -0,0 +1 @@
+export {};

package/dist/realtime-handler.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Type-only base class for Realtime Handlers.
+ *
+ * Import and extend this in your handler files:
+ *   import { RealtimeHandler } from "@base44/sdk";
+ *   export class MyHandler extends RealtimeHandler { ... }
+ *
+ * At deploy time the bundler replaces this import with the compiled
+ * Cloudflare Durable Object implementation — this file provides types only.
+ */
+import type { Base44Client } from "./client.types.js";
+/**
+ * A single client connection. `Send` is the message type this connection accepts
+ * via {@link send} — the handler's *outgoing* (server→client) messages.
+ */
+export interface Conn<Send = unknown> {
+    /** Unique per-connection id (one per socket/tab), the same value the client
+     *  receives from `subscribe()`. Use this — not userId — to identify a distinct
+     *  client, so multiple tabs of the same user are separate connections. */
+    id: string;
+    userId: string;
+    appId: string;
+    instanceId: string;
+    send(data: Send): void;
+    reject(code: number, reason: string): void;
+}
+export interface Storage {
+    get<T>(key: string): Promise<T | undefined>;
+    put(key: string, value: unknown): Promise<void>;
+    delete(key: string): Promise<boolean>;
+}
+/**
+ * Base class for a Realtime Handler.
+ *
+ * @typeParam Incoming - messages this handler *receives* from clients
+ *   (`handleMessage`'s `msg`) — the schema's `toServer` section.
+ * @typeParam Outgoing - messages this handler *sends* to clients
+ *   (`conn.send`/`broadcast`) — the schema's `toClient` section.
+ *
+ * With a generated `schema.jsonc`, wire both from the registry so they can't drift
+ * from the client's types:
+ * ```ts
+ * type Reg = RealtimeHandlerRegistry["MyHandler"];
+ * class MyHandler extends RealtimeHandler<Reg["toServer"], Reg["toClient"]> { ... }
+ * ```
+ */
+export declare abstract class RealtimeHandler<Incoming = unknown, Outgoing = unknown> {
+    abstract handleConnect(conn: Conn<Outgoing>): void | Promise<void>;
+    abstract handleMessage(conn: Conn<Outgoing>, msg: Incoming): void | Promise<void>;
+    abstract handleClose(conn: Conn<Outgoing>): void | Promise<void>;
+    abstract handleTick(): void | Promise<void>;
+    onStart(): void | Promise<void>;
+    /**
+     * Managed ticker (opt-in). Override {@link shouldTick} and the platform runs
+     * {@link handleTick} on a timer of {@link tickIntervalMs} while it returns true,
+     * and stops (letting the Durable Object hibernate — no compute cost) when it
+     * returns false. The platform owns scheduling, rescheduling, self-heal, and
+     * error-safety — you don't call {@link startLoop}/{@link stopLoop}.
+     *
+     * Re-evaluated after every connect/message/close and on every tick, so keep it
+     * cheap and pure (no async, no side effects). Example: `return this.players >= 2`.
+     */
+    protected tickIntervalMs: number;
+    protected shouldTick?(): boolean;
+    protected broadcast(_data: Outgoing): void;
+    protected getConnections(): Conn<Outgoing>[];
+    protected startLoop(_ms: number): Promise<void>;
+    protected stopLoop(): Promise<void>;
+    protected get instanceId(): string;
+    protected get storage(): Storage;
+    /**
+     * SDK client acting **as the connected user** — every entity call respects
+     * the app's row-level security, evaluated as that user at call time. The
+     * default wherever a `conn` is in scope (connect/message/close).
+     *
+     * Anonymous connections get an unauthenticated client — entity calls run
+     * under anonymous RLS, just like any public visitor.
+     */
+    protected createClientFromConnection(conn: Conn): Base44Client;
+    /**
+     * Service-role SDK client — bypasses RLS. For work with **no user in scope**
+     * (tick, alarm, onStart). Inside handleMessage/handleConnect prefer
+     * `createClientFromConnection(conn)`.
+     */
+    protected createServiceClient(): Base44Client;
+}

package/dist/realtime-handler.js

@@ -0,0 +1,79 @@
+/**
+ * Type-only base class for Realtime Handlers.
+ *
+ * Import and extend this in your handler files:
+ *   import { RealtimeHandler } from "@base44/sdk";
+ *   export class MyHandler extends RealtimeHandler { ... }
+ *
+ * At deploy time the bundler replaces this import with the compiled
+ * Cloudflare Durable Object implementation — this file provides types only.
+ */
+/**
+ * Base class for a Realtime Handler.
+ *
+ * @typeParam Incoming - messages this handler *receives* from clients
+ *   (`handleMessage`'s `msg`) — the schema's `toServer` section.
+ * @typeParam Outgoing - messages this handler *sends* to clients
+ *   (`conn.send`/`broadcast`) — the schema's `toClient` section.
+ *
+ * With a generated `schema.jsonc`, wire both from the registry so they can't drift
+ * from the client's types:
+ * ```ts
+ * type Reg = RealtimeHandlerRegistry["MyHandler"];
+ * class MyHandler extends RealtimeHandler<Reg["toServer"], Reg["toClient"]> { ... }
+ * ```
+ */
+export class RealtimeHandler {
+    constructor() {
+        /**
+         * Managed ticker (opt-in). Override {@link shouldTick} and the platform runs
+         * {@link handleTick} on a timer of {@link tickIntervalMs} while it returns true,
+         * and stops (letting the Durable Object hibernate — no compute cost) when it
+         * returns false. The platform owns scheduling, rescheduling, self-heal, and
+         * error-safety — you don't call {@link startLoop}/{@link stopLoop}.
+         *
+         * Re-evaluated after every connect/message/close and on every tick, so keep it
+         * cheap and pure (no async, no side effects). Example: `return this.players >= 2`.
+         */
+        this.tickIntervalMs = 100;
+    }
+    onStart() { }
+    broadcast(_data) {
+        throw new Error("RealtimeHandler.broadcast() is only available inside a deployed handler");
+    }
+    getConnections() {
+        throw new Error("RealtimeHandler.getConnections() is only available inside a deployed handler");
+    }
+    startLoop(_ms) {
+        throw new Error("RealtimeHandler.startLoop() is only available inside a deployed handler");
+    }
+    stopLoop() {
+        throw new Error("RealtimeHandler.stopLoop() is only available inside a deployed handler");
+    }
+    get instanceId() {
+        throw new Error("RealtimeHandler.instanceId is only available inside a deployed handler");
+    }
+    get storage() {
+        throw new Error("RealtimeHandler.storage is only available inside a deployed handler");
+    }
+    /**
+     * SDK client acting **as the connected user** — every entity call respects
+     * the app's row-level security, evaluated as that user at call time. The
+     * default wherever a `conn` is in scope (connect/message/close).
+     *
+     * Anonymous connections get an unauthenticated client — entity calls run
+     * under anonymous RLS, just like any public visitor.
+     */
+    createClientFromConnection(conn) {
+        void conn;
+        throw new Error("RealtimeHandler.createClientFromConnection() is only available inside a deployed handler");
+    }
+    /**
+     * Service-role SDK client — bypasses RLS. For work with **no user in scope**
+     * (tick, alarm, onStart). Inside handleMessage/handleConnect prefer
+     * `createClientFromConnection(conn)`.
+     */
+    createServiceClient() {
+        throw new Error("RealtimeHandler.createServiceClient() is only available inside a deployed handler");
+    }
+}

package/dist/utils/axios-client.js

@@ -130,7 +130,9 @@ export function createAxiosClient({ baseURL, headers = {}, token, interceptRespo
     }
     // Add origin URL in browser environment
     client.interceptors.request.use((config) => {
-        if (typeof window !== "undefined") {
+        // `window.location` is absent on React Native (where `window` still exists),
+        // so guard on it before reading `.href`.
+        if (typeof window !== "undefined" && window.location) {
             config.headers.set("X-Origin-URL", window.location.href);
             // On unauthenticated requests, attach a stable anonymous visitor id so the
             // backend can support anonymous agent access (conversation grouping + ownership).

package/dist/utils/common.d.ts

@@ -1,3 +1,4 @@
 export declare const isNode: boolean;
 export declare const isInIFrame: boolean;
+export declare const isReactNative: boolean;
 export declare const generateUuid: () => string;

package/dist/utils/common.js

@@ -1,5 +1,10 @@
 export const isNode = typeof window === "undefined";
 export const isInIFrame = !isNode && window.self !== window.top;
+// React Native defines `window` (so `isNode` is false there) but not `document`.
+// Browser-only code paths gated on `window`/`isNode` alone would run — and crash —
+// on React Native. Node (no `window`) is already handled by those `window` guards;
+// this flags the window-without-a-DOM case that isn't.
+export const isReactNative = !isNode && typeof document === "undefined";
 export const generateUuid = () => {
     return (Math.random().toString(36).substring(2, 15) +
         Math.random().toString(36).substring(2, 15));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@base44-preview/sdk",
-  "version": "0.8.36-pr.219.4b81d03",
+  "version": "0.8.37-pr.212.00d8065",
   "description": "JavaScript SDK for Base44 API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -27,6 +27,7 @@
   },
   "dependencies": {
     "axios": "^1.17.0",
+    "partysocket": "^0.0.23",
     "socket.io-client": "^4.8.3",
     "uuid": "^13.0.2"
   },