@mitway/sdk 0.2.4 → 0.3.0

package/dist/index.d.cts

@@ -70,6 +70,7 @@ declare class TokenManager {
  */
 
 type PostgresChangesEventSelector = 'INSERT' | 'UPDATE' | 'DELETE' | '*';
+/** Filter for any event (including the `*` catch-all). */
 interface PostgresChangesFilter {
     event: PostgresChangesEventSelector;
     schema?: string;
@@ -77,8 +78,8 @@ interface PostgresChangesFilter {
     /** PostgREST-style filter: `column=op.value` or `column=in.(a,b,c)`. */
     filter?: string;
 }
-interface PostgresChangesPayload<T = Record<string, unknown>> {
-    type: 'INSERT' | 'UPDATE' | 'DELETE';
+/** Common shape shared by every postgres_changes payload variant. */
+interface PostgresChangesPayloadBase {
     schema: string;
     table: string;
     commit_timestamp: string;
@@ -86,10 +87,33 @@ interface PostgresChangesPayload<T = Record<string, unknown>> {
         name: string;
         type: string;
     }>;
-    record?: T;
-    old_record?: T;
     errors?: string[];
 }
+/** INSERT: the new row is in `new`. `old` is kept as an empty object so
+ *  code that accesses both fields never needs optional chaining. */
+interface PostgresChangesInsertPayload<T = Record<string, unknown>> extends PostgresChangesPayloadBase {
+    eventType: 'INSERT';
+    new: T;
+    old: Record<string, never>;
+}
+/** UPDATE: both `new` and `old` are populated. `old` is `Partial<T>`
+ *  because RLS / REPLICA IDENTITY may strip columns the subscriber can't
+ *  see. */
+interface PostgresChangesUpdatePayload<T = Record<string, unknown>> extends PostgresChangesPayloadBase {
+    eventType: 'UPDATE';
+    new: T;
+    old: Partial<T>;
+}
+/** DELETE: the deleted row is in `old`. On RLS-enabled tables only
+ *  primary-key columns are populated. `new` is always an empty object. */
+interface PostgresChangesDeletePayload<T = Record<string, unknown>> extends PostgresChangesPayloadBase {
+    eventType: 'DELETE';
+    new: Record<string, never>;
+    old: Partial<T>;
+}
+/** Discriminated union — what the `'*'` overload of `on('postgres_changes',
+ *  ...)` passes to the callback. */
+type PostgresChangesPayload<T = Record<string, unknown>> = PostgresChangesInsertPayload<T> | PostgresChangesUpdatePayload<T> | PostgresChangesDeletePayload<T>;
 interface BroadcastFilter {
     event: string;
 }
@@ -140,11 +164,6 @@ interface ChannelOptions {
          *  requested on a private channel. Default: `false` (open topic). */
         private?: boolean;
         broadcast?: {
-            /** When true, `channel.send(...)` resolves only after the server
-             *  ack'd the publish — useful if the app wants to know the
-             *  message_id assigned by the server. Default: `false`
-             *  (fire-and-forget). */
-            ack?: boolean;
             /** When `false`, the sending socket is excluded from the fan-out.
              *  Default: `true` (sender also receives its own broadcasts). */
             self?: boolean;
@@ -158,9 +177,13 @@ interface ChannelOptions {
     };
 }
 type ChannelStatus = 'SUBSCRIBED' | 'CHANNEL_ERROR' | 'TIMED_OUT' | 'CLOSED';
-type ChannelStatusCallback = (status: ChannelStatus, error?: {
-    code: string;
-    message: string;
+/** Callback invoked for every channel status transition. The second
+ *  argument is a standard `Error` (so consumers can annotate it as
+ *  `err: Error` out of the box) with a non-standard `.code` string
+ *  attached for programmatic discrimination (`SUBSCRIBE_FAILED`,
+ *  `CONNECT_FAILED`, `REJOIN_FAILED`, …). */
+type ChannelStatusCallback = (status: ChannelStatus, error?: Error & {
+    code?: string;
 }) => void;
 interface RealtimeOptions {
     path?: string;
@@ -168,9 +191,10 @@ interface RealtimeOptions {
     timeoutMs?: number;
     extraAuth?: Record<string, string>;
 }
-type PostgresChangesCallback<T = Record<string, unknown>> = (payload: PostgresChangesPayload<T>) => void;
 type BroadcastCallback<T = Record<string, unknown>> = (payload: BroadcastPayload<T>) => void;
-type PresenceCallback<T = Record<string, unknown>> = (payload: PresencePayload<T>) => void;
+type PresenceSyncCallback = () => void;
+type PresenceJoinCallback<T = Record<string, unknown>> = (payload: PresenceJoinPayload<T>) => void;
+type PresenceLeaveCallback<T = Record<string, unknown>> = (payload: PresenceLeavePayload<T>) => void;
 declare class RealtimeChannel {
     readonly topic: string;
     private readonly realtime;
@@ -204,9 +228,40 @@ declare class RealtimeChannel {
      *  statusCallback (from the original subscribe()) fires again with
      *  'SUBSCRIBED' or 'CHANNEL_ERROR' so the app can reflect state. */
     _rejoinAfterReconnect(): Promise<void>;
-    on<T = Record<string, unknown>>(type: 'postgres_changes', filter: PostgresChangesFilter, callback: PostgresChangesCallback<T>): this;
+    on<T = Record<string, unknown>>(type: 'postgres_changes', filter: {
+        event: 'INSERT';
+        schema?: string;
+        table: string;
+        filter?: string;
+    }, callback: (payload: PostgresChangesInsertPayload<T>) => void): this;
+    on<T = Record<string, unknown>>(type: 'postgres_changes', filter: {
+        event: 'UPDATE';
+        schema?: string;
+        table: string;
+        filter?: string;
+    }, callback: (payload: PostgresChangesUpdatePayload<T>) => void): this;
+    on<T = Record<string, unknown>>(type: 'postgres_changes', filter: {
+        event: 'DELETE';
+        schema?: string;
+        table: string;
+        filter?: string;
+    }, callback: (payload: PostgresChangesDeletePayload<T>) => void): this;
+    on<T = Record<string, unknown>>(type: 'postgres_changes', filter: {
+        event: '*';
+        schema?: string;
+        table: string;
+        filter?: string;
+    }, callback: (payload: PostgresChangesPayload<T>) => void): this;
     on<T = Record<string, unknown>>(type: 'broadcast', filter: BroadcastFilter, callback: BroadcastCallback<T>): this;
-    on<T = Record<string, unknown>>(type: 'presence', filter: PresenceFilter, callback: PresenceCallback<T>): this;
+    on(type: 'presence', filter: {
+        event: 'sync';
+    }, callback: PresenceSyncCallback): this;
+    on<T = Record<string, unknown>>(type: 'presence', filter: {
+        event: 'join';
+    }, callback: PresenceJoinCallback<T>): this;
+    on<T = Record<string, unknown>>(type: 'presence', filter: {
+        event: 'leave';
+    }, callback: PresenceLeaveCallback<T>): this;
     /**
      * Register or refresh this client's presence entry on the channel. Safe
      * to call many times — state replaces (not merges). Starts a heartbeat
@@ -248,21 +303,27 @@ declare class RealtimeChannel {
      * events, write to your own application table and enable
      * `postgres_changes` on it; the SDK will surface the INSERT as a
      * `postgres_changes` event without a separate channel.send call.
+     *
+     * The returned promise always resolves with the server ack, so callers
+     * can `await channel.send(...)` to confirm delivery + get the server-
+     * assigned `message_id`. There's no performance cost — Socket.IO piggy-
+     * backs the ack on the same frame. Callers that don't need it just
+     * don't await.
      */
     send<T extends Record<string, unknown>>(args: {
         type: 'broadcast';
         event: string;
         payload: T;
     }): Promise<{
-        ok: true;
+        status: 'ok';
         message_id: string;
     } | {
-        ok: false;
+        status: 'error';
         error: {
             code: string;
             message: string;
         };
-    } | void>;
+    }>;
     /**
      * Replay SQL-originated broadcasts on this topic since the given
      * timestamp. Delivered only to this socket (same envelope format as
@@ -301,13 +362,14 @@ declare class Realtime {
      * The optional `opts` argument lets the caller configure the channel:
      *   * `config.private` — enable subscribe-side authorization against
      *     `realtime.authorize_subscribe(...)` on the tenant DB.
-     *   * `config.broadcast.ack` — `channel.send()` resolves with the
-     *     server's ack (message_id) instead of fire-and-forget.
      *   * `config.broadcast.self` — `false` excludes the sender from the
      *     fan-out (defaults to `true`).
      *   * `config.presence.key` — stable presence key to group multiple
      *     tabs of the same user under one entry.
      *
+     * `channel.send()` always resolves with the server ack (see its own
+     * docstring); there is no separate opt-in needed.
+     *
      * Options are locked in when the channel is first created; subsequent
      * `.channel('same')` calls with different opts are ignored. Pass a
      * different topic to get a different-configured channel.
@@ -729,4 +791,4 @@ declare class MitwayBaasClient {
  */
 declare function createClient(config: MitwayBaasConfig): MitwayBaasClient;
 
-export { type ApiError, Auth, type AuthRefreshResponse, type AuthResponse, type AuthResult, type AuthSession, type BroadcastFilter, type BroadcastPayload, type ChannelOptions, type ChannelStatus, type ChannelStatusCallback, Database, HttpClient, Logger, MitwayBaasClient, type MitwayBaasConfig, MitwayBaasError, type PostgresChangesEventSelector, type PostgresChangesFilter, type PostgresChangesPayload, type PresenceEventSelector, type PresenceFilter, type PresenceJoinPayload, type PresenceLeavePayload, type PresencePayload, type PresenceState, type PresenceSyncPayload, Realtime, RealtimeChannel, type RealtimeMessageMeta, type RealtimeOptions, type SignInRequest, type SignUpRequest, TokenManager, type User, createClient, MitwayBaasClient as default };
+export { type ApiError, Auth, type AuthRefreshResponse, type AuthResponse, type AuthResult, type AuthSession, type BroadcastFilter, type BroadcastPayload, type ChannelOptions, type ChannelStatus, type ChannelStatusCallback, Database, HttpClient, Logger, MitwayBaasClient, type MitwayBaasConfig, MitwayBaasError, type PostgresChangesDeletePayload, type PostgresChangesEventSelector, type PostgresChangesFilter, type PostgresChangesInsertPayload, type PostgresChangesPayload, type PostgresChangesUpdatePayload, type PresenceEventSelector, type PresenceFilter, type PresenceJoinPayload, type PresenceLeavePayload, type PresencePayload, type PresenceState, type PresenceSyncPayload, Realtime, RealtimeChannel, type RealtimeMessageMeta, type RealtimeOptions, type SignInRequest, type SignUpRequest, TokenManager, type User, createClient, MitwayBaasClient as default };

package/dist/index.d.ts

@@ -70,6 +70,7 @@ declare class TokenManager {
  */
 
 type PostgresChangesEventSelector = 'INSERT' | 'UPDATE' | 'DELETE' | '*';
+/** Filter for any event (including the `*` catch-all). */
 interface PostgresChangesFilter {
     event: PostgresChangesEventSelector;
     schema?: string;
@@ -77,8 +78,8 @@ interface PostgresChangesFilter {
     /** PostgREST-style filter: `column=op.value` or `column=in.(a,b,c)`. */
     filter?: string;
 }
-interface PostgresChangesPayload<T = Record<string, unknown>> {
-    type: 'INSERT' | 'UPDATE' | 'DELETE';
+/** Common shape shared by every postgres_changes payload variant. */
+interface PostgresChangesPayloadBase {
     schema: string;
     table: string;
     commit_timestamp: string;
@@ -86,10 +87,33 @@ interface PostgresChangesPayload<T = Record<string, unknown>> {
         name: string;
         type: string;
     }>;
-    record?: T;
-    old_record?: T;
     errors?: string[];
 }
+/** INSERT: the new row is in `new`. `old` is kept as an empty object so
+ *  code that accesses both fields never needs optional chaining. */
+interface PostgresChangesInsertPayload<T = Record<string, unknown>> extends PostgresChangesPayloadBase {
+    eventType: 'INSERT';
+    new: T;
+    old: Record<string, never>;
+}
+/** UPDATE: both `new` and `old` are populated. `old` is `Partial<T>`
+ *  because RLS / REPLICA IDENTITY may strip columns the subscriber can't
+ *  see. */
+interface PostgresChangesUpdatePayload<T = Record<string, unknown>> extends PostgresChangesPayloadBase {
+    eventType: 'UPDATE';
+    new: T;
+    old: Partial<T>;
+}
+/** DELETE: the deleted row is in `old`. On RLS-enabled tables only
+ *  primary-key columns are populated. `new` is always an empty object. */
+interface PostgresChangesDeletePayload<T = Record<string, unknown>> extends PostgresChangesPayloadBase {
+    eventType: 'DELETE';
+    new: Record<string, never>;
+    old: Partial<T>;
+}
+/** Discriminated union — what the `'*'` overload of `on('postgres_changes',
+ *  ...)` passes to the callback. */
+type PostgresChangesPayload<T = Record<string, unknown>> = PostgresChangesInsertPayload<T> | PostgresChangesUpdatePayload<T> | PostgresChangesDeletePayload<T>;
 interface BroadcastFilter {
     event: string;
 }
@@ -140,11 +164,6 @@ interface ChannelOptions {
          *  requested on a private channel. Default: `false` (open topic). */
         private?: boolean;
         broadcast?: {
-            /** When true, `channel.send(...)` resolves only after the server
-             *  ack'd the publish — useful if the app wants to know the
-             *  message_id assigned by the server. Default: `false`
-             *  (fire-and-forget). */
-            ack?: boolean;
             /** When `false`, the sending socket is excluded from the fan-out.
              *  Default: `true` (sender also receives its own broadcasts). */
             self?: boolean;
@@ -158,9 +177,13 @@ interface ChannelOptions {
     };
 }
 type ChannelStatus = 'SUBSCRIBED' | 'CHANNEL_ERROR' | 'TIMED_OUT' | 'CLOSED';
-type ChannelStatusCallback = (status: ChannelStatus, error?: {
-    code: string;
-    message: string;
+/** Callback invoked for every channel status transition. The second
+ *  argument is a standard `Error` (so consumers can annotate it as
+ *  `err: Error` out of the box) with a non-standard `.code` string
+ *  attached for programmatic discrimination (`SUBSCRIBE_FAILED`,
+ *  `CONNECT_FAILED`, `REJOIN_FAILED`, …). */
+type ChannelStatusCallback = (status: ChannelStatus, error?: Error & {
+    code?: string;
 }) => void;
 interface RealtimeOptions {
     path?: string;
@@ -168,9 +191,10 @@ interface RealtimeOptions {
     timeoutMs?: number;
     extraAuth?: Record<string, string>;
 }
-type PostgresChangesCallback<T = Record<string, unknown>> = (payload: PostgresChangesPayload<T>) => void;
 type BroadcastCallback<T = Record<string, unknown>> = (payload: BroadcastPayload<T>) => void;
-type PresenceCallback<T = Record<string, unknown>> = (payload: PresencePayload<T>) => void;
+type PresenceSyncCallback = () => void;
+type PresenceJoinCallback<T = Record<string, unknown>> = (payload: PresenceJoinPayload<T>) => void;
+type PresenceLeaveCallback<T = Record<string, unknown>> = (payload: PresenceLeavePayload<T>) => void;
 declare class RealtimeChannel {
     readonly topic: string;
     private readonly realtime;
@@ -204,9 +228,40 @@ declare class RealtimeChannel {
      *  statusCallback (from the original subscribe()) fires again with
      *  'SUBSCRIBED' or 'CHANNEL_ERROR' so the app can reflect state. */
     _rejoinAfterReconnect(): Promise<void>;
-    on<T = Record<string, unknown>>(type: 'postgres_changes', filter: PostgresChangesFilter, callback: PostgresChangesCallback<T>): this;
+    on<T = Record<string, unknown>>(type: 'postgres_changes', filter: {
+        event: 'INSERT';
+        schema?: string;
+        table: string;
+        filter?: string;
+    }, callback: (payload: PostgresChangesInsertPayload<T>) => void): this;
+    on<T = Record<string, unknown>>(type: 'postgres_changes', filter: {
+        event: 'UPDATE';
+        schema?: string;
+        table: string;
+        filter?: string;
+    }, callback: (payload: PostgresChangesUpdatePayload<T>) => void): this;
+    on<T = Record<string, unknown>>(type: 'postgres_changes', filter: {
+        event: 'DELETE';
+        schema?: string;
+        table: string;
+        filter?: string;
+    }, callback: (payload: PostgresChangesDeletePayload<T>) => void): this;
+    on<T = Record<string, unknown>>(type: 'postgres_changes', filter: {
+        event: '*';
+        schema?: string;
+        table: string;
+        filter?: string;
+    }, callback: (payload: PostgresChangesPayload<T>) => void): this;
     on<T = Record<string, unknown>>(type: 'broadcast', filter: BroadcastFilter, callback: BroadcastCallback<T>): this;
-    on<T = Record<string, unknown>>(type: 'presence', filter: PresenceFilter, callback: PresenceCallback<T>): this;
+    on(type: 'presence', filter: {
+        event: 'sync';
+    }, callback: PresenceSyncCallback): this;
+    on<T = Record<string, unknown>>(type: 'presence', filter: {
+        event: 'join';
+    }, callback: PresenceJoinCallback<T>): this;
+    on<T = Record<string, unknown>>(type: 'presence', filter: {
+        event: 'leave';
+    }, callback: PresenceLeaveCallback<T>): this;
     /**
      * Register or refresh this client's presence entry on the channel. Safe
      * to call many times — state replaces (not merges). Starts a heartbeat
@@ -248,21 +303,27 @@ declare class RealtimeChannel {
      * events, write to your own application table and enable
      * `postgres_changes` on it; the SDK will surface the INSERT as a
      * `postgres_changes` event without a separate channel.send call.
+     *
+     * The returned promise always resolves with the server ack, so callers
+     * can `await channel.send(...)` to confirm delivery + get the server-
+     * assigned `message_id`. There's no performance cost — Socket.IO piggy-
+     * backs the ack on the same frame. Callers that don't need it just
+     * don't await.
      */
     send<T extends Record<string, unknown>>(args: {
         type: 'broadcast';
         event: string;
         payload: T;
     }): Promise<{
-        ok: true;
+        status: 'ok';
         message_id: string;
     } | {
-        ok: false;
+        status: 'error';
         error: {
             code: string;
             message: string;
         };
-    } | void>;
+    }>;
     /**
      * Replay SQL-originated broadcasts on this topic since the given
      * timestamp. Delivered only to this socket (same envelope format as
@@ -301,13 +362,14 @@ declare class Realtime {
      * The optional `opts` argument lets the caller configure the channel:
      *   * `config.private` — enable subscribe-side authorization against
      *     `realtime.authorize_subscribe(...)` on the tenant DB.
-     *   * `config.broadcast.ack` — `channel.send()` resolves with the
-     *     server's ack (message_id) instead of fire-and-forget.
      *   * `config.broadcast.self` — `false` excludes the sender from the
      *     fan-out (defaults to `true`).
      *   * `config.presence.key` — stable presence key to group multiple
      *     tabs of the same user under one entry.
      *
+     * `channel.send()` always resolves with the server ack (see its own
+     * docstring); there is no separate opt-in needed.
+     *
      * Options are locked in when the channel is first created; subsequent
      * `.channel('same')` calls with different opts are ignored. Pass a
      * different topic to get a different-configured channel.
@@ -729,4 +791,4 @@ declare class MitwayBaasClient {
  */
 declare function createClient(config: MitwayBaasConfig): MitwayBaasClient;
 
-export { type ApiError, Auth, type AuthRefreshResponse, type AuthResponse, type AuthResult, type AuthSession, type BroadcastFilter, type BroadcastPayload, type ChannelOptions, type ChannelStatus, type ChannelStatusCallback, Database, HttpClient, Logger, MitwayBaasClient, type MitwayBaasConfig, MitwayBaasError, type PostgresChangesEventSelector, type PostgresChangesFilter, type PostgresChangesPayload, type PresenceEventSelector, type PresenceFilter, type PresenceJoinPayload, type PresenceLeavePayload, type PresencePayload, type PresenceState, type PresenceSyncPayload, Realtime, RealtimeChannel, type RealtimeMessageMeta, type RealtimeOptions, type SignInRequest, type SignUpRequest, TokenManager, type User, createClient, MitwayBaasClient as default };
+export { type ApiError, Auth, type AuthRefreshResponse, type AuthResponse, type AuthResult, type AuthSession, type BroadcastFilter, type BroadcastPayload, type ChannelOptions, type ChannelStatus, type ChannelStatusCallback, Database, HttpClient, Logger, MitwayBaasClient, type MitwayBaasConfig, MitwayBaasError, type PostgresChangesDeletePayload, type PostgresChangesEventSelector, type PostgresChangesFilter, type PostgresChangesInsertPayload, type PostgresChangesPayload, type PostgresChangesUpdatePayload, type PresenceEventSelector, type PresenceFilter, type PresenceJoinPayload, type PresenceLeavePayload, type PresencePayload, type PresenceState, type PresenceSyncPayload, Realtime, RealtimeChannel, type RealtimeMessageMeta, type RealtimeOptions, type SignInRequest, type SignUpRequest, TokenManager, type User, createClient, MitwayBaasClient as default };

package/dist/index.js

@@ -857,6 +857,11 @@ var Database = class {
 // src/modules/realtime.ts
 import { io } from "socket.io-client";
 var PRESENCE_HEARTBEAT_MS = 2e4;
+function makeChannelError(code, message) {
+  const err = new Error(message);
+  err.code = code;
+  return err;
+}
 var DEFAULT_CONNECT_TIMEOUT_MS = 1e4;
 var RealtimeChannel = class {
   constructor(topic, realtime, options = {}) {
@@ -927,12 +932,19 @@ var RealtimeChannel = class {
       this.statusCallback?.("SUBSCRIBED");
     } catch (err) {
       this.state = "errored";
-      this.statusCallback?.("CHANNEL_ERROR", {
-        code: "REJOIN_FAILED",
-        message: err instanceof Error ? err.message : String(err)
-      });
+      this.statusCallback?.(
+        "CHANNEL_ERROR",
+        makeChannelError("REJOIN_FAILED", err instanceof Error ? err.message : String(err))
+      );
     }
   }
+  // ── implementation signature (not in public type surface).
+  // The callback type is intentionally broad: each overload above pins a
+  // specific payload shape, but TypeScript overload resolution needs the
+  // implementation to accept the union of every narrow callback without
+  // the contravariance conflict (TS2394). `any` is the standard escape
+  // hatch for this exact pattern and is confined to this one line — the
+  // public surface users see is strictly typed via the overloads.
   on(type, filter, callback) {
     if (type === "postgres_changes") {
       this.bindings.push({
@@ -1034,18 +1046,18 @@ var RealtimeChannel = class {
         } catch (err) {
           this.state = "errored";
           const message = err instanceof Error ? err.message : String(err);
-          this.statusCallback?.("CHANNEL_ERROR", {
-            code: "SUBSCRIBE_FAILED",
-            message
-          });
+          this.statusCallback?.(
+            "CHANNEL_ERROR",
+            makeChannelError("SUBSCRIBE_FAILED", message)
+          );
         }
       },
       (err) => {
         this.state = "errored";
-        this.statusCallback?.("CHANNEL_ERROR", {
-          code: "CONNECT_FAILED",
-          message: err.message
-        });
+        this.statusCallback?.(
+          "CHANNEL_ERROR",
+          makeChannelError("CONNECT_FAILED", err.message)
+        );
       }
     );
     return this;
@@ -1098,6 +1110,12 @@ var RealtimeChannel = class {
    * events, write to your own application table and enable
    * `postgres_changes` on it; the SDK will surface the INSERT as a
    * `postgres_changes` event without a separate channel.send call.
+   *
+   * The returned promise always resolves with the server ack, so callers
+   * can `await channel.send(...)` to confirm delivery + get the server-
+   * assigned `message_id`. There's no performance cost — Socket.IO piggy-
+   * backs the ack on the same frame. Callers that don't need it just
+   * don't await.
    */
   async send(args) {
     if (args.type !== "broadcast") {
@@ -1124,9 +1142,7 @@ var RealtimeChannel = class {
     if (!socket) {
       throw new MitwayBaasError("Socket not connected", 503, "NOT_CONNECTED");
     }
-    const broadcastCfg = this.options.config?.broadcast;
-    const wantAck = broadcastCfg?.ack === true;
-    const self = broadcastCfg?.self;
+    const self = this.options.config?.broadcast?.self;
     const wirePayload = {
       channel: this.topic,
       event: args.event,
@@ -1135,10 +1151,6 @@ var RealtimeChannel = class {
     if (self === false) {
       wirePayload.self = false;
     }
-    if (!wantAck) {
-      socket.emit("realtime:publish", wirePayload);
-      return;
-    }
     return await new Promise((resolve) => {
       socket.emit(
         "realtime:publish",
@@ -1179,7 +1191,7 @@ var RealtimeChannel = class {
         if (!b.subscriptionId || !pcEvent.ids.includes(b.subscriptionId)) {
           continue;
         }
-        const matchesEvent = b.filter.event === "*" || b.filter.event === pcEvent.data.type;
+        const matchesEvent = b.filter.event === "*" || b.filter.event === pcEvent.data.eventType;
         if (!matchesEvent) {
           continue;
         }
@@ -1238,7 +1250,13 @@ var RealtimeChannel = class {
         continue;
       }
       try {
-        b.callback(payload);
+        if (payload.event === "sync") {
+          b.callback();
+        } else if (payload.event === "join") {
+          b.callback(payload);
+        } else {
+          b.callback(payload);
+        }
       } catch {
       }
     }
@@ -1257,7 +1275,7 @@ var RealtimeChannel = class {
           "realtime:subscribe",
           { channel: this.topic, private: this.isPrivate },
           (ack) => {
-            if (ack.ok) {
+            if (ack.status === "ok") {
               resolve();
             } else {
               reject(new Error(ack.error?.message ?? "subscribe failed"));
@@ -1281,7 +1299,7 @@ var RealtimeChannel = class {
               filter: b.filter.filter
             },
             (ack) => {
-              if (ack.ok && ack.subscription_id) {
+              if (ack.status === "ok" && ack.subscription_id) {
                 b.subscriptionId = ack.subscription_id;
                 resolve();
               } else {
@@ -1327,13 +1345,14 @@ var Realtime = class {
    * The optional `opts` argument lets the caller configure the channel:
    *   * `config.private` — enable subscribe-side authorization against
    *     `realtime.authorize_subscribe(...)` on the tenant DB.
-   *   * `config.broadcast.ack` — `channel.send()` resolves with the
-   *     server's ack (message_id) instead of fire-and-forget.
    *   * `config.broadcast.self` — `false` excludes the sender from the
    *     fan-out (defaults to `true`).
    *   * `config.presence.key` — stable presence key to group multiple
    *     tabs of the same user under one entry.
    *
+   * `channel.send()` always resolves with the server ack (see its own
+   * docstring); there is no separate opt-in needed.
+   *
    * Options are locked in when the channel is first created; subsequent
    * `.channel('same')` calls with different opts are ignored. Pass a
    * different topic to get a different-configured channel.