@base44-preview/sdk 0.8.36-pr.212.0d64c77 → 0.8.36-pr.219.4b81d03

package/dist/client.js

@@ -12,7 +12,6 @@ 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, pushUserTokenToActiveSockets } from "./modules/realtime.js";
 /**
  * Creates a Base44 client.
  *
@@ -52,19 +51,9 @@ import { createRealtimeModule, pushUserTokenToActiveSockets } from "./modules/re
  */
 export function createClient(config) {
     var _a, _b;
-    const { serverUrl = "https://base44.app", appId, token, serviceToken, requiresAuth = false, appBaseUrl, options, functionsVersion, headers: optionalHeaders, dispatcherWsUrl, webSocketImpl, } = config;
+    const { serverUrl = "https://base44.app", appId, token, serviceToken, requiresAuth = false, appBaseUrl, options, functionsVersion, headers: optionalHeaders, } = 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 from serverUrl if not explicitly provided.
-    // Convert https:// → wss:// (or http:// → ws://) and strip trailing slash.
-    const resolvedDispatcherWsUrl = (() => {
-        if (dispatcherWsUrl)
-            return dispatcherWsUrl.replace(/\/$/, "");
-        return serverUrl
-            .replace(/\/$/, "")
-            .replace(/^https:\/\//, "wss://")
-            .replace(/^http:\/\//, "ws://");
-    })();
     const socketConfig = {
         serverUrl,
         mountPath: "/ws-user-apps/socket.io/",
@@ -124,21 +113,6 @@ export function createClient(config) {
         appBaseUrl: normalizedAppBaseUrl,
         serverUrl,
     });
-    // Current user session token (axios defaults are the single source of truth —
-    // createClient({token}) and every setToken() land there). Used for in-band
-    // realtime auth; read lazily so refreshes are always picked up.
-    const getUserToken = () => {
-        var _a;
-        const h = (_a = axiosClient.defaults.headers.common) === null || _a === void 0 ? void 0 : _a["Authorization"];
-        return typeof h === "string" && h.startsWith("Bearer ") ? h.slice(7) : null;
-    };
-    // Login / token refresh must reach long-lived realtime sockets too, so the
-    // handler-side credential never goes stale mid-connection.
-    const originalSetToken = userAuthModule.setToken.bind(userAuthModule);
-    userAuthModule.setToken = (newToken, saveToStorage) => {
-        originalSetToken(newToken, saveToStorage);
-        pushUserTokenToActiveSockets(newToken);
-    };
     // Apply the access token before any module that may issue authenticated
     // requests during construction (notably analytics, which fires an init
     // event whose flush calls auth.me()). Without this, the first User/me
@@ -186,31 +160,6 @@ export function createClient(config) {
             appId,
             userAuthModule,
         }),
-        realtime: createRealtimeModule({
-            appId,
-            dispatcherWsUrl: resolvedDispatcherWsUrl,
-            webSocketImpl,
-            getUserToken,
-            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,
-                    // Declares "an __auth message follows right after connect" — the
-                    // handler delays handleConnect until it arrives (signed into the
-                    // token so old SDKs, which never send __auth, are never waited on).
-                    supports_inband_auth: getUserToken() != null,
-                }, functionsVersion
-                    ? { headers: { "Base44-Functions-Version": functionsVersion } }
-                    : undefined);
-                return data.token;
-            },
-        }),
         cleanup: () => {
             userModules.analytics.cleanup();
             if (socket) {

package/dist/client.types.d.ts

@@ -8,7 +8,6 @@ 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.
  */
@@ -74,25 +73,6 @@ export interface CreateClientConfig {
      * Additional client options.
      */
     options?: CreateClientOptions;
-    /**
-     * Base WebSocket URL for the Cloudflare Durable Object dispatcher.
-     *
-     * Defaults to the `serverUrl` with `https://` replaced by `wss://` (or `http://` by `ws://`).
-     * Override when the dispatcher lives at a different host than the API.
-     */
-    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.
@@ -108,8 +88,6 @@ 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,9 +11,7 @@ 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,4 +3,3 @@ 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/package.json

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

package/dist/modules/realtime.d.ts

@@ -1,28 +0,0 @@
-/** Push a (new) user session token to every open realtime socket — called on
- *  login/refresh so long-lived connections keep a valid credential server-side. */
-export declare function pushUserTokenToActiveSockets(token: string): void;
-export declare function createRealtimeModule(config: {
-    appId: string;
-    getToken(handlerName: string, instanceId: string, connId: string): Promise<string>;
-    /** Current user session token, if signed in. Sent in-band ({type:"__auth"})
-     *  right after every socket open — never in the URL — so the handler can act
-     *  as this user (createUserClient / RLS). */
-    getUserToken?: () => string | null;
-    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

@@ -1,124 +0,0 @@
-import PartySocket from "partysocket";
-// Module-level map: "HandlerName:instanceId" → active socket
-const activeSockets = new Map();
-function socketKey(handlerName, instanceId) {
-    return `${handlerName}:${instanceId}`;
-}
-/** Push a (new) user session token to every open realtime socket — called on
- *  login/refresh so long-lived connections keep a valid credential server-side. */
-export function pushUserTokenToActiveSockets(token) {
-    if (!token)
-        return;
-    const payload = JSON.stringify({ type: "__auth", token });
-    for (const ws of activeSockets.values()) {
-        try {
-            ws.send(payload);
-        }
-        catch ( /* not open — the open handler will send */_a) { /* not open — the open handler will send */ }
-    }
-}
-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,
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                        ...(config.webSocketImpl ? { WebSocket: config.webSocketImpl } : {}),
-                        query: () => config.getToken(handlerName, instanceId, connId).then((token) => ({ token })),
-                    });
-                    activeSockets.set(key, ws);
-                    // In-band credential delivery (Supabase-style): the user token rides the
-                    // open socket, never the URL. Sent on every open (incl. reconnects); the
-                    // server may also nudge with {type:"__auth_required"} (e.g. just before
-                    // the held token expires) and we answer with the current one.
-                    const sendAuth = () => {
-                        var _a;
-                        const t = (_a = config.getUserToken) === null || _a === void 0 ? void 0 : _a.call(config);
-                        if (t) {
-                            try {
-                                ws.send(JSON.stringify({ type: "__auth", token: t }));
-                            }
-                            catch ( /* not open */_b) { /* not open */ }
-                        }
-                    };
-                    ws.addEventListener("open", sendAuth);
-                    // 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.
-                    // Pairs with the handler's setWebSocketAutoResponse("__ping"→"__pong"),
-                    // so idle handlers (no app broadcasts) still keep the connection proven.
-                    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;
-                        if (msgType === "__auth_required") {
-                            sendAuth();
-                            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

@@ -1,77 +0,0 @@
-/**
- * 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

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

package/dist/realtime-handler.d.ts

@@ -1,86 +0,0 @@
-/**
- * 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).
-     *
-     * Throws if the connection carries no user credential (anonymous visitor,
-     * signed-out session, or an app SDK that predates in-band auth).
-     */
-    protected createUserClient(conn: Conn): Base44Client;
-    /**
-     * Service-role SDK client — bypasses RLS. For work with **no user in scope**
-     * (tick, alarm, onStart). Inside handleMessage/handleConnect prefer
-     * `createUserClient(conn)`.
-     */
-    protected createServiceClient(): Base44Client;
-}

package/dist/realtime-handler.js

@@ -1,79 +0,0 @@
-/**
- * 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).
-     *
-     * Throws if the connection carries no user credential (anonymous visitor,
-     * signed-out session, or an app SDK that predates in-band auth).
-     */
-    createUserClient(conn) {
-        void conn;
-        throw new Error("RealtimeHandler.createUserClient() 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
-     * `createUserClient(conn)`.
-     */
-    createServiceClient() {
-        throw new Error("RealtimeHandler.createServiceClient() is only available inside a deployed handler");
-    }
-}