@base44-preview/sdk 0.8.46-pr.273.f546cdd → 0.8.46-pr.274.c9536b0

package/dist/actor.d.ts

@@ -6,12 +6,12 @@
  *   export class MyActor extends Actor { ... }
  *
  * At deploy time the bundler replaces this import with the compiled
- * Cloudflare Durable Object implementation. This file provides types only.
+ * Cloudflare Durable Object implementation — this file provides types only.
  */
 import type { Base44Client } from "./client";
 /**
  * A single client connection. `Send` is the message type this connection accepts
- * via {@link send}, the actor's *outgoing* (server→client) messages.
+ * via {@link send} — the actor's *outgoing* (server→client) messages.
  */
 export interface Conn<Send = unknown> {
     /** Unique per-connection id (one per socket/tab), the same value the client
@@ -33,9 +33,9 @@ export interface Storage {
  * Base class for an Actor.
  *
  * @typeParam Incoming - messages this actor *receives* from clients
- *   (`handleMessage`'s `msg`), the schema's `toServer` section.
+ *   (`handleMessage`'s `msg`) — the schema's `toServer` section.
  * @typeParam Outgoing - messages this actor *sends* to clients
- *   (`conn.send`/`broadcast`), the schema's `toClient` section.
+ *   (`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:
@@ -51,7 +51,7 @@ export declare abstract class Actor<Incoming = unknown, Outgoing = unknown> {
     abstract handleTick(): void | Promise<void>;
     /**
      * Optional wake hook: runs once when the instance starts, before any
-     * connection is handled. It is safe to load persisted state here.
+     * connection is handled — safe to load persisted state here.
      */
     handleStart(): void | Promise<void>;
     /**
@@ -71,7 +71,7 @@ export declare abstract class Actor<Incoming = unknown, Outgoing = unknown> {
     /**
      * 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 at no compute cost) when it
+     * and stops (letting the Durable Object hibernate — no compute cost) when it
      * returns false. The platform owns scheduling, rescheduling, self-heal, and
      * error-safety.
      *
@@ -85,7 +85,7 @@ export declare abstract class Actor<Incoming = unknown, Outgoing = unknown> {
     protected get instanceId(): string;
     protected get storage(): Storage;
     /**
-     * Anonymous Base44 client scoped to this actor instance, with no user or service
+     * Anonymous Base44 client scoped to this actor instance — no user or service
      * auth, so entity access is RLS-gated (same as a logged-out visitor). Always
      * operates on production data: an actor runs server-side with no per-connection
      * identity, so a Test DB preview selected in the editor does not apply here.

package/dist/actor.js

@@ -6,15 +6,15 @@
  *   export class MyActor extends Actor { ... }
  *
  * At deploy time the bundler replaces this import with the compiled
- * Cloudflare Durable Object implementation. This file provides types only.
+ * Cloudflare Durable Object implementation — this file provides types only.
  */
 /**
  * Base class for an Actor.
  *
  * @typeParam Incoming - messages this actor *receives* from clients
- *   (`handleMessage`'s `msg`), the schema's `toServer` section.
+ *   (`handleMessage`'s `msg`) — the schema's `toServer` section.
  * @typeParam Outgoing - messages this actor *sends* to clients
- *   (`conn.send`/`broadcast`), the schema's `toClient` section.
+ *   (`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:
@@ -28,7 +28,7 @@ export class Actor {
         /**
          * 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 at no compute cost) when it
+         * and stops (letting the Durable Object hibernate — no compute cost) when it
          * returns false. The platform owns scheduling, rescheduling, self-heal, and
          * error-safety.
          *
@@ -39,7 +39,7 @@ export class Actor {
     }
     /**
      * Optional wake hook: runs once when the instance starts, before any
-     * connection is handled. It is safe to load persisted state here.
+     * connection is handled — safe to load persisted state here.
      */
     handleStart() { }
     /**
@@ -73,7 +73,7 @@ export class Actor {
         throw new Error("Actor.storage is only available inside a deployed actor");
     }
     /**
-     * Anonymous Base44 client scoped to this actor instance, with no user or service
+     * Anonymous Base44 client scoped to this actor instance — no user or service
      * auth, so entity access is RLS-gated (same as a logged-out visitor). Always
      * operates on production data: an actor runs server-side with no per-connection
      * identity, so a Test DB preview selected in the editor does not apply here.

package/dist/client.js

@@ -113,7 +113,7 @@ export function createClient(config) {
     });
     // Dedicated client for actor connection-token mints: no onError (a legacy
     // actor answers every mint with an expected 409 before the proxy fallback,
-    // which must not reach the app's error handler; the actors module forwards
+    // which must not reach the app's error handler — the actors module forwards
     // genuine failures itself via onMintError) and no constructor token
     // (auth is per-request so a login/logout is picked up on every reconnect).
     const actorsAxiosClient = createAxiosClient({

package/dist/client.types.d.ts

@@ -18,14 +18,14 @@ export interface CreateClientOptions {
      * Optional error handler that will be called whenever an API error occurs.
      *
      * Also receives {@link ActorsModule | actors} connection failures. Errors
-     * are usually {@linkcode Base44Error} instances, so check `error.status`.
+     * are usually {@linkcode Base44Error} instances — check `error.status`.
      */
     onError?: (error: Error) => void;
     /**
      * Forces the actors transport. `"auto"` (default) connects directly to the
      * actor and falls back to the platform proxy when the app's actors don't
      * support direct connections; `"proxy"` always uses the platform proxy
-     * (ops rollback, with no connection-token calls); `"direct"` disables the
+     * (ops rollback — no connection-token calls); `"direct"` disables the
      * fallback (validation environments).
      * @internal
      */

package/dist/modules/actors.d.ts

@@ -35,7 +35,7 @@ interface ActorsConfig {
  * The legacy platform-proxy URL, byte-for-byte what PartySocket built before
  * the direct path existed: same scheme swap (including its localhost-needs-a-
  * port quirk), case-preserved party segment, `_pk` first in the query. The
- * `handler` param is load-bearing. The proxy reads it for the actor name.
+ * `handler` param is load-bearing — the proxy reads it for the actor name.
  */
 export declare function buildProxyActorUrl(rawHost: string, actorName: string, instanceId: string, connectionId: string, appId: string, token: string | null | undefined, functionsVersion?: string): string;
 /**

package/dist/modules/actors.js

@@ -8,12 +8,12 @@ const DEAD_MS = 3000;
 // 422 = no principal (e.g. anonymous outside a browser) or an id/room only the
 // proxy's looser validation accepts, 405 = a backend that predates the mint
 // endpoint (its actor deploy routes catch the path via `{handler_name:path}`
-// but not the POST method, and the real endpoint never 405s a POST). The
+// but not the POST method — and the real endpoint never 405s a POST). The
 // proxy serves migrated actors too, so falling back is always safe.
 const PROXY_FALLBACK_STATUSES = new Set([405, 409, 422, 503]);
 // Mint responses no retry can fix (bad request / forbidden / not found): the
 // connection closes instead of re-minting forever; a fresh connect() re-probes.
-// 401 is deliberately absent. The auth token is re-read on every attempt, so a
+// 401 is deliberately absent — the auth token is re-read on every attempt, so a
 // login recovers on the next retry. Disjoint from PROXY_FALLBACK_STATUSES.
 const TERMINAL_MINT_STATUSES = new Set([400, 403, 404]);
 /** The mint's rejection can be anything; a `Base44Error` carries a numeric
@@ -29,7 +29,7 @@ function toError(err) {
 }
 /**
  * A live connection to an actor instance. Only obtainable from
- * {@link ActorRef.connect}, so `subscribe`/`send` are always valid. The socket
+ * {@link ActorRef.connect}, so `subscribe`/`send` are always valid — the socket
  * exists for this object's whole lifetime.
  */
 class Connection {
@@ -44,7 +44,7 @@ class Connection {
         // mint answers with a fallback status the choice is sticky for this
         // socket's lifetime (a fresh connect() after close() probes direct again,
         // picking up actors migrated in the meantime). Any other mint failure
-        // rejects, which ReconnectingWebSocket retries with backoff, except the
+        // rejects, which ReconnectingWebSocket retries with backoff — except the
         // terminal statuses, which close this connection for good.
         let useProxy = config.transport === "proxy";
         const urlProvider = async () => {
@@ -172,7 +172,7 @@ function makeActorRef(actorName, instanceId, config, connections) {
  * The legacy platform-proxy URL, byte-for-byte what PartySocket built before
  * the direct path existed: same scheme swap (including its localhost-needs-a-
  * port quirk), case-preserved party segment, `_pk` first in the query. The
- * `handler` param is load-bearing. The proxy reads it for the actor name.
+ * `handler` param is load-bearing — the proxy reads it for the actor name.
  */
 export function buildProxyActorUrl(rawHost, actorName, instanceId, connectionId, appId, token, functionsVersion) {
     let host = rawHost.replace(/^(http|https|ws|wss):\/\//, "");

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

@@ -7,7 +7,6 @@
  *
  * @example
  * ```typescript
- * // Declare message types for a deployed actor
  * declare module "@base44/sdk" {
  *   interface ActorRegistry {
  *     ChatRoom: {
@@ -22,7 +21,7 @@ export interface ActorRegistry {
 }
 /**
  * Auto-populated by `base44 types generate` with the names of your deployed actors.
- * Do not edit this interface manually. Use {@link ActorRegistry} for message types.
+ * Do not edit this interface manually — use {@link ActorRegistry} for message types.
  */
 export interface ActorNameRegistry {
 }
@@ -36,136 +35,55 @@ type ToServerFor<N extends string> = N extends keyof ActorRegistry ? ActorRegist
 /** Options for {@link ActorRef.connect}. */
 export interface ActorConnectOptions {
     /**
-     * The connection id, used as the actor's `conn.id`. Supply a stable value,
-     * such as one persisted per tab, so a reconnect reuses the same server-side
-     * identity. Omit it for an auto-generated per-connection id.
+     * The connection id — becomes the actor's `conn.id`. Supply a stable value
+     * (e.g. persisted per tab) so a reconnect reuses the same server-side
+     * identity; omit for an auto-generated per-connection id.
      */
     id?: string;
 }
 /** Handle for one listener registered via {@link Connection.subscribe}. */
 export interface ActorSubscription {
-    /**
-     * Removes this listener. Other listeners on the same connection, and the
-     * connection itself, stay live. To close the connection as well, call
-     * {@link Connection.close}.
-     *
-     * @example
-     * ```typescript
-     * // Stop listening without closing the connection
-     * const sub = conn.subscribe((msg) => console.log(msg));
-     * sub.unsubscribe();
-     * ```
-     */
+    /** Remove this listener; other listeners and the socket stay live. */
     unsubscribe(): void;
 }
 /**
  * A live connection to an actor instance, returned by {@link ActorRef.connect}.
- * `subscribe`/`send` are always valid. You only get a `Connection` once the
+ * `subscribe`/`send` are always valid — you only get a `Connection` once the
  * socket has been opened, so there's no pre-connect state to guard against.
  */
 export interface Connection<N extends string = string> {
-    /** The connection id, which is the value the actor sees as `conn.id`. */
+    /** The connection id (the value the actor sees as `conn.id`). */
     readonly id: string;
-    /**
-     * Registers a listener for messages sent by the actor. Any number of
-     * listeners can be registered on one connection, and each receives every
-     * message.
-     *
-     * The callback payload is typed when the actor is declared in
-     * {@link ActorRegistry}, and is `unknown` otherwise.
-     *
-     * @param callback - Called with each message the actor sends to this client.
-     * @returns An {@link ActorSubscription} that removes this one listener.
-     *
-     * @example
-     * ```typescript
-     * // Listen for messages from the actor
-     * const sub = conn.subscribe((msg) => {
-     *   if (msg.type === "message") console.log(msg.text);
-     * });
-     * ```
-     */
+    /** Register a message listener. Multiple are allowed; returns a per-listener unsubscribe. */
     subscribe(callback: (data: ToClientFor<N>) => void): ActorSubscription;
-    /**
-     * Sends a message to the actor.
-     *
-     * Messages sent before the socket finishes opening are buffered and flushed
-     * on open. Messages sent after {@link close} are dropped silently.
-     *
-     * The payload is typed when the actor is declared in {@link ActorRegistry},
-     * and is `unknown` otherwise.
-     *
-     * @param data - The message to send to the actor.
-     *
-     * @example
-     * ```typescript
-     * // Send a message to the actor
-     * conn.send({ type: "message", text: "hi" });
-     * ```
-     */
+    /** Send a message. Buffered by the socket until it's open; dropped after
+     * {@link close}. */
     send(data: ToServerFor<N>): void;
     /**
-     * Closes the connection, tearing down the socket, the heartbeat, and every
-     * listener registered on it. Safe to call more than once.
-     *
-     * A connection also closes itself when it fails permanently. See
-     * {@link ActorRef.connect} for how to recover from that.
-     *
-     * @example
-     * ```typescript
-     * // Close when the view that opened the connection goes away.
-     * useEffect(() => {
-     *   const conn = base44.actors.ChatRoom(roomId).connect();
-     *   conn.subscribe(setMessage);
-     *   return () => conn.close();
-     * }, [roomId]);
-     * ```
+     * Tear down the socket, heartbeat, and all listeners. Safe to call more
+     * than once. A connection also closes itself when it fails permanently —
+     * see {@link ActorRef.connect}.
      */
     close(): void;
 }
 /**
- * A handle to one actor instance, obtained from `base44.actors.MyActor(id)`. Call
+ * A handle to one actor instance — `base44.actors.MyActor(id)`. Call
  * {@link connect} to open the socket and get a {@link Connection}.
  */
 export interface ActorRef<N extends string = string> {
     /**
-     * Opens the WebSocket to this actor instance and returns the
-     * {@link Connection}. Idempotent while the connection is open, so calling it
-     * again returns the same connection rather than opening a second socket.
-     *
-     * The returned connection is usable straight away. Messages passed to
-     * {@link Connection.send} before the socket finishes opening are buffered and
-     * flushed on open.
-     *
-     * A connection that fails permanently, for example because the actor doesn't
-     * exist or the caller isn't allowed to connect, closes itself and reports the
-     * error to the client's `onError` handler. Call `connect()` again once the
-     * cause is fixed to get a fresh {@link Connection}, then re-subscribe, as
-     * listeners do not carry over.
-     *
-     * @param options - Connection options. See {@link ActorConnectOptions}.
-     * @returns A live {@link Connection} to this actor instance.
-     *
-     * @example
-     * ```typescript
-     * // Connect to an actor instance
-     * const conn = base44.actors.ChatRoom("room-1").connect();
-     * ```
-     *
-     * @example
-     * ```typescript
-     * // Reuse a stable connection id so a reconnect keeps the same
-     * // server-side identity.
-     * let id = sessionStorage.getItem("chat-conn-id") ?? crypto.randomUUID();
-     * sessionStorage.setItem("chat-conn-id", id);
+     * Open the WebSocket and return the {@link Connection}. Idempotent while the
+     * connection is open.
      *
-     * const conn = base44.actors.ChatRoom("room-1").connect({ id });
-     * ```
+     * A connection that fails permanently (for example, the actor doesn't exist
+     * or the caller isn't allowed to connect) closes itself and reports the
+     * error to the client's `onError` handler. Call `connect()` again after
+     * fixing the cause to get a fresh {@link Connection}, and re-subscribe.
      */
     connect(options?: ActorConnectOptions): Connection<N>;
 }
 /**
- * Client for a single named Actor. Call it with an instance id to get an
+ * Client for a single named Actor — call it with an instance id to get an
  * {@link ActorRef}. Typed automatically when the actor is registered in
  * {@link ActorRegistry}.
  */
@@ -173,62 +91,16 @@ export interface ActorClient<N extends string = string> {
     (instanceId: string): ActorRef<N>;
 }
 /**
- * Actors module for real-time messaging with Cloudflare Durable Object-backed
+ * The actors module provides access to Cloudflare Durable Object-backed
  * Actors deployed by the Base44 platform.
  *
- * An Actor is a named server-side object with persistent state. Each instance
- * is addressed by an id, so `base44.actors.ChatRoom("room-1")` and
- * `base44.actors.ChatRoom("room-2")` are separate instances with separate
- * state. Clients open a WebSocket to an instance and exchange messages with it.
- *
- * This module provides:
- * - Per-instance WebSocket connections, opened with {@link ActorRef.connect}
- * - Message listeners, registered with {@link Connection.subscribe}
- * - Message sending, with {@link Connection.send}
- * - Automatic reconnection with backoff, including recovery from half-open
- *   sockets that stop delivering messages without emitting a close event
- * - End-to-end typing of message payloads through {@link ActorRegistry}
- *
- * This module is available to use with a client in anonymous and user
- * authentication modes. Connecting anonymously requires a browser environment.
- *
- * Connections stay open until you call {@link Connection.close}, so close them
- * when the view that opened them goes away.
- *
- * @example
  * ```typescript
- * // Open a connection to one instance of the ChatRoom actor.
- * const conn = base44.actors.ChatRoom("room-1").connect();
- *
- * const sub = conn.subscribe((msg) => {
- *   console.log(msg);
- * });
- *
+ * const conn = base44.actors.MyActor("room-1").connect();
+ * const sub = conn.subscribe((msg) => console.log(msg)); // typed via ActorRegistry
  * conn.send({ type: "message", text: "hi" });
- *
- * // Later, when the view goes away.
  * sub.unsubscribe();
  * conn.close();
  * ```
- *
- * @example
- * ```typescript
- * // Register the actor to type both directions of the conversation.
- * declare module "@base44/sdk" {
- *   interface ActorRegistry {
- *     ChatRoom: {
- *       toClient: { type: "joined" | "message"; from?: string; text?: string };
- *       toServer: { type: "message"; text: string };
- *     };
- *   }
- * }
- *
- * const conn = base44.actors.ChatRoom("room-1").connect();
- * conn.subscribe((msg) => {
- *   // msg is typed as the toClient union.
- *   if (msg.type === "message") console.log(msg.text);
- * });
- * ```
  */
 export type ActorsModule = {
     [K in AllActorNames]: K extends keyof ActorRegistry ? ActorClient<string & K> : ActorClient;

package/dist/modules/analytics.js

@@ -25,7 +25,7 @@ const analyticsSharedState = getSharedInstance(ANALYTICS_SHARED_STATE_NAME, () =
     wasInitializationTracked: false,
     sessionContext: null,
     sessionStartTime: null,
-    // Memoized session id for when `localStorage` can't persist one. See
+    // Memoized session id for when `localStorage` can't persist one — see
     // getAnalyticsSessionId.
     fallbackSessionId: null,
     config: {
@@ -255,7 +255,7 @@ async function getSessionContext(userAuthModule) {
         // With no token there is no identity to resolve: `me()` can only answer 401,
         // which the browser logs to the console before any handler here sees it. On
         // a public page that request is the sole reason an error appears, so skip
-        // it. This is not memoized. A visitor who logs in later must still resolve.
+        // it. This is not memoized — a visitor who logs in later must still resolve.
         if (!userAuthModule.hasToken()) {
             return { user_id: null, session_id: getAnalyticsSessionId() };
         }

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

@@ -21,7 +21,7 @@ export interface AppPublicSettingsResponse {
  * ## Authentication Modes
  *
  * This module is available to use with a client in all authentication modes. The
- * client's token, when it has one, is sent with the request, so a signed-in visitor
+ * client's token, when it has one, is sent with the request — a signed-in visitor
  * who has no access to the app is reported differently from an anonymous one.
  */
 export interface AppModule {
@@ -29,9 +29,9 @@ export interface AppModule {
      * Get the app's public configuration.
      *
      * Rejects with a {@linkcode Base44Error} when the visitor may not open the app:
-     * `status` is `403` and `data.extra_data.reason` says why. It is
-     * `"auth_required"` when the visitor must sign in, and
-     * `"user_not_registered"` when the signed-in visitor has no access to this app.
+     * `status` is `403` and `data.extra_data.reason` says why — `"auth_required"`
+     * when the visitor must sign in, `"user_not_registered"` when the signed-in
+     * visitor has no access to this app.
      *
      * @returns Promise resolving to the app's ID and access policy.
      *

package/dist/modules/auth.js

@@ -70,7 +70,7 @@ export function createAuthModule(axios, functionsAxiosClient, appId, options) {
     // two identical GETs, so the second pays the first's full latency on every
     // cold load.
     //
-    // This shares the pending promise only, and it is cleared as soon as the request
+    // This shares the pending promise only — it is cleared as soon as the request
     // settles, so no resolved user is ever retained. Caching the user across
     // requests would leave the app rendering a stale identity after logout or a
     // session swap.

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

@@ -526,7 +526,7 @@ export interface AuthModule {
 /**
  * The auth module as constructed internally, before it is narrowed to
  * {@link AuthModule} on the public client. Not exported from the package
- * index. SDK consumers see only {@link AuthModule}.
+ * index — SDK consumers see only {@link AuthModule}.
  *
  * @internal
  */
@@ -534,7 +534,7 @@ export interface InternalAuthModule extends AuthModule {
     /**
      * Whether an access token is currently set on the client.
      *
-     * Reports only the presence of a token, never its validity. An expired or
+     * Reports only the presence of a token, never its validity — an expired or
      * revoked token still reads as `true`. Callers use this to skip requests that
      * could not succeed without a session, not to decide that one is valid.
      */

package/dist/modules/connectors.js

@@ -93,8 +93,8 @@ function assertNonEmptyString(value, label) {
  * POST a request to the connector proxy and normalize the response.
  *
  * The proxy reports upstream outcomes in the body rather than as HTTP status, so
- * a provider 4xx/5xx arrives here as a resolved response with `success: false`.
- * Only Base44-side failures reject through the axios error interceptor.
+ * a provider 4xx/5xx arrives here as a resolved response with `success: false` —
+ * only Base44-side failures reject through the axios error interceptor.
  *
  * @internal
  */

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

@@ -87,7 +87,7 @@ export interface ConnectorApiResponse<T = unknown> {
     status: number | null;
     /**
      * The parsed upstream response body, or proxy error details when no response
-     * was received. It is `null` when the response was binary. See {@link dataBase64}.
+     * was received. `null` when the response was binary — see {@link dataBase64}.
      */
     data: T | null;
     /**
@@ -148,9 +148,9 @@ export interface ConnectorProxyRawResponse {
  *
  * ## Metered connectors
  *
- * A few [platform connectors](#shared-connectors) are backed by paid third-party APIs that charge Base44 per call. For those, the OAuth token is **not** available to your code, and {@linkcode getConnection | getConnection()} rejects with a `403`. Call them with {@linkcode callApi | callApi()} instead. Base44 attaches the credential server-side, forwards the request, and bills your workspace's integration credits for the call.
+ * A few [platform connectors](#shared-connectors) are backed by paid third-party APIs that charge Base44 per call. For those, the OAuth token is **not** available to your code — {@linkcode getConnection | getConnection()} rejects with a `403`. Call them with {@linkcode callApi | callApi()} instead: Base44 attaches the credential server-side, forwards the request, and bills your workspace's integration credits for the call.
  *
- * This applies to platform connectors only. A workspace-registered or app user connector runs on **your own** OAuth app, so the provider invoices you directly and there is nothing for Base44 to meter. Those keep normal token access via {@linkcode getWorkspaceConnection | getWorkspaceConnection()} and {@linkcode getCurrentAppUserConnection | getCurrentAppUserConnection()}.
+ * This applies to platform connectors only. A workspace-registered or app user connector runs on **your own** OAuth app, so the provider invoices you directly and there is nothing for Base44 to meter — those keep normal token access via {@linkcode getWorkspaceConnection | getWorkspaceConnection()} and {@linkcode getCurrentAppUserConnection | getCurrentAppUserConnection()}.
  *
  * Two things to keep in mind when writing against a metered connector:
  *
@@ -422,7 +422,7 @@ export interface ConnectorsModule {
      *
      * @param integrationType - The type of integration, such as `'x'`. See [Available connectors](#available-connectors).
      * @param request - The upstream request to forward. See {@link ConnectorApiRequest}.
-     * @returns Promise resolving to a {@link ConnectorApiResponse}. Note that an upstream error is reported in `success` and `status`, not thrown. Only Base44-side failures reject.
+     * @returns Promise resolving to a {@link ConnectorApiResponse}. Note that an upstream error is reported in `success` and `status`, not thrown — only Base44-side failures reject.
      *
      * @example
      * ```typescript

package/dist/modules/entities.js

@@ -143,7 +143,7 @@ function createEntityHandler(axios, appId, entityName, getSocket) {
                     // developer console so they know to fetch the full record on
                     // demand (e.g. a follow-up entities.X.get(id) call) instead of
                     // rendering the slimmed payload directly. Skip on delete events
-                    // because the record no longer exists.
+                    // — the record no longer exists.
                     if (event.type !== "delete" && ((_a = event.data) === null || _a === void 0 ? void 0 : _a._oversize)) {
                         console.error(`[Base44 SDK] Realtime broadcast for ${entityName}#${event.id} was oversize and got slimmed for transport. ` +
                             `Fields >10 KB are empty and the rest of the record may be a stub. ` +

package/dist/utils/common.js

@@ -1,7 +1,7 @@
 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,
+// 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";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@base44-preview/sdk",
-  "version": "0.8.46-pr.273.f546cdd",
+  "version": "0.8.46-pr.274.c9536b0",
   "description": "JavaScript SDK for Base44 API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",