@eventmodelers/node-kit 0.0.2

package/templates/realtime-agent/node_modules/@supabase/realtime-js/src/RealtimePresence.ts

@@ -0,0 +1,71 @@
+/*
+  This file draws heavily from https://github.com/phoenixframework/phoenix/blob/d344ec0a732ab4ee204215b31de69cf4be72e3bf/assets/js/phoenix/presence.js
+  License: https://github.com/phoenixframework/phoenix/blob/d344ec0a732ab4ee204215b31de69cf4be72e3bf/LICENSE.md
+*/
+
+import type RealtimeChannel from './RealtimeChannel'
+import PresenceAdapter from './phoenix/presenceAdapter'
+
+export type Presence<T extends { [key: string]: any } = {}> = {
+  presence_ref: string
+} & T
+
+export type RealtimePresenceState<T extends { [key: string]: any } = {}> = {
+  [key: string]: Presence<T>[]
+}
+
+export type RealtimePresenceJoinPayload<T extends { [key: string]: any }> = {
+  event: `${REALTIME_PRESENCE_LISTEN_EVENTS.JOIN}`
+  key: string
+  currentPresences: Presence<T>[]
+  newPresences: Presence<T>[]
+}
+
+export type RealtimePresenceLeavePayload<T extends { [key: string]: any }> = {
+  event: `${REALTIME_PRESENCE_LISTEN_EVENTS.LEAVE}`
+  key: string
+  currentPresences: Presence<T>[]
+  leftPresences: Presence<T>[]
+}
+
+export enum REALTIME_PRESENCE_LISTEN_EVENTS {
+  SYNC = 'sync',
+  JOIN = 'join',
+  LEAVE = 'leave',
+}
+
+export type RealtimePresenceOptions = {
+  events?: { state: string; diff: string }
+}
+
+export default class RealtimePresence {
+  get state() {
+    return this.presenceAdapter.state
+  }
+
+  private presenceAdapter: PresenceAdapter
+
+  /**
+   * Creates a Presence helper that keeps the local presence state in sync with the server.
+   *
+   * @param channel - The realtime channel to bind to.
+   * @param opts - Optional custom event names, e.g. `{ events: { state: 'state', diff: 'diff' } }`.
+   *
+   * @category Realtime
+   *
+   * @example Example for a presence channel
+   * ```ts
+   * const presence = new RealtimePresence(channel)
+   *
+   * channel.on('presence', ({ event, key }) => {
+   *   console.log(`Presence ${event} on ${key}`)
+   * })
+   * ```
+   */
+  constructor(
+    public channel: RealtimeChannel,
+    opts?: RealtimePresenceOptions
+  ) {
+    this.presenceAdapter = new PresenceAdapter(this.channel.channelAdapter, opts)
+  }
+}

package/templates/realtime-agent/node_modules/@supabase/realtime-js/src/index.ts

@@ -0,0 +1,53 @@
+import RealtimeClient, {
+  RealtimeClientOptions,
+  RealtimeMessage,
+  RealtimeRemoveChannelResponse,
+  WebSocketLikeConstructor,
+} from './RealtimeClient'
+import RealtimeChannel, {
+  RealtimeChannelOptions,
+  RealtimeChannelSendResponse,
+  RealtimePostgresChangesFilter,
+  RealtimePostgresChangesPayload,
+  RealtimePostgresInsertPayload,
+  RealtimePostgresUpdatePayload,
+  RealtimePostgresDeletePayload,
+  REALTIME_LISTEN_TYPES,
+  REALTIME_POSTGRES_CHANGES_LISTEN_EVENT,
+  REALTIME_SUBSCRIBE_STATES,
+  REALTIME_CHANNEL_STATES,
+} from './RealtimeChannel'
+import RealtimePresence, {
+  RealtimePresenceState,
+  RealtimePresenceJoinPayload,
+  RealtimePresenceLeavePayload,
+  REALTIME_PRESENCE_LISTEN_EVENTS,
+} from './RealtimePresence'
+import WebSocketFactory, { WebSocketLike } from './lib/websocket-factory'
+
+export {
+  RealtimePresence,
+  RealtimeChannel,
+  RealtimeChannelOptions,
+  RealtimeChannelSendResponse,
+  RealtimeClient,
+  RealtimeClientOptions,
+  RealtimeMessage,
+  RealtimePostgresChangesFilter,
+  RealtimePostgresChangesPayload,
+  RealtimePostgresInsertPayload,
+  RealtimePostgresUpdatePayload,
+  RealtimePostgresDeletePayload,
+  RealtimePresenceJoinPayload,
+  RealtimePresenceLeavePayload,
+  RealtimePresenceState,
+  RealtimeRemoveChannelResponse,
+  REALTIME_LISTEN_TYPES,
+  REALTIME_POSTGRES_CHANGES_LISTEN_EVENT,
+  REALTIME_PRESENCE_LISTEN_EVENTS,
+  REALTIME_SUBSCRIBE_STATES,
+  REALTIME_CHANNEL_STATES,
+  WebSocketFactory,
+  WebSocketLike,
+  WebSocketLikeConstructor,
+}

package/templates/realtime-agent/node_modules/@supabase/realtime-js/src/lib/constants.ts

@@ -0,0 +1,62 @@
+import { version } from './version'
+import type {
+  SocketState,
+  ChannelState,
+  ChannelEvent as PhoenixChannelEvent,
+  Transport,
+  Vsn,
+} from '../phoenix/types'
+
+export type { SocketState, ChannelState, Transport }
+
+export const DEFAULT_VERSION = `realtime-js/${version}`
+
+export const VSN_1_0_0: Vsn = '1.0.0'
+export const VSN_2_0_0: Vsn = '2.0.0'
+export const DEFAULT_VSN: Vsn = VSN_2_0_0
+
+export const VERSION = version
+
+export const DEFAULT_TIMEOUT = 10000
+
+export const WS_CLOSE_NORMAL = 1000
+export const MAX_PUSH_BUFFER_SIZE = 100
+
+export const SOCKET_STATES = {
+  connecting: 0,
+  open: 1,
+  closing: 2,
+  closed: 3,
+} as const
+
+export const CHANNEL_STATES = {
+  closed: 'closed',
+  errored: 'errored',
+  joined: 'joined',
+  joining: 'joining',
+  leaving: 'leaving',
+} as const
+
+export type ChannelEvent = PhoenixChannelEvent | 'access_token'
+
+export const CHANNEL_EVENTS = {
+  close: 'phx_close',
+  error: 'phx_error',
+  join: 'phx_join',
+  reply: 'phx_reply',
+  leave: 'phx_leave',
+  access_token: 'access_token',
+} as const
+
+export const TRANSPORTS = {
+  websocket: 'websocket',
+} as const
+
+export type ConnectionState = 'connecting' | 'open' | 'closing' | 'closed' | (string & {})
+
+export const CONNECTION_STATE = {
+  connecting: 'connecting',
+  open: 'open',
+  closing: 'closing',
+  closed: 'closed',
+} as const

package/templates/realtime-agent/node_modules/@supabase/realtime-js/src/lib/normalizeChannelError.ts

@@ -0,0 +1,30 @@
+/**
+ * Normalize the various shapes a channel error reason can take into a real `Error`.
+ *
+ * Transport-level channel errors arrive as a `CloseEvent`, a transport `Event`, an `Error`,
+ * a string, or `undefined` depending on which path in the underlying socket fired. Server-reply
+ * errors arrive as a payload object. This helper produces a consistent `Error` for every case
+ * and preserves the original via `cause` so callers can still inspect the raw event.
+ */
+export function normalizeChannelError(reason: unknown): Error {
+  if (reason instanceof Error) {
+    return reason
+  }
+
+  if (typeof reason === 'string') {
+    return new Error(reason)
+  }
+
+  if (reason && typeof reason === 'object') {
+    const obj = reason as Record<string, unknown>
+
+    if (typeof obj.code === 'number') {
+      const detail = typeof obj.reason === 'string' && obj.reason ? ` (${obj.reason})` : ''
+      return new Error(`socket closed: ${obj.code}${detail}`, { cause: reason })
+    }
+
+    return new Error('channel error: transport failure', { cause: reason })
+  }
+
+  return new Error('channel error: connection lost')
+}

package/templates/realtime-agent/node_modules/@supabase/realtime-js/src/lib/serializer.ts

@@ -0,0 +1,203 @@
+// This file draws heavily from https://github.com/phoenixframework/phoenix/commit/cf098e9cf7a44ee6479d31d911a97d3c7430c6fe
+// License: https://github.com/phoenixframework/phoenix/blob/master/LICENSE.md
+export type Msg<T> = {
+  join_ref?: string | null
+  ref?: string | null
+  topic: string
+  event: string
+  payload: T
+}
+
+export default class Serializer {
+  HEADER_LENGTH = 1
+  USER_BROADCAST_PUSH_META_LENGTH = 6
+  KINDS = { userBroadcastPush: 3, userBroadcast: 4 }
+  BINARY_ENCODING = 0
+  JSON_ENCODING = 1
+  BROADCAST_EVENT = 'broadcast'
+
+  allowedMetadataKeys: string[] = []
+
+  constructor(allowedMetadataKeys?: string[] | null) {
+    this.allowedMetadataKeys = allowedMetadataKeys ?? []
+  }
+
+  encode(msg: Msg<{ [key: string]: any }>, callback: (result: ArrayBuffer | string) => any) {
+    if (
+      msg.event === this.BROADCAST_EVENT &&
+      !(msg.payload instanceof ArrayBuffer) &&
+      typeof msg.payload.event === 'string'
+    ) {
+      return callback(
+        this._binaryEncodeUserBroadcastPush(msg as Msg<{ event: string } & { [key: string]: any }>)
+      )
+    }
+
+    let payload = [msg.join_ref, msg.ref, msg.topic, msg.event, msg.payload]
+    return callback(JSON.stringify(payload))
+  }
+
+  private _binaryEncodeUserBroadcastPush(message: Msg<{ event: string } & { [key: string]: any }>) {
+    if (this._isArrayBuffer(message.payload?.payload)) {
+      return this._encodeBinaryUserBroadcastPush(message)
+    } else {
+      return this._encodeJsonUserBroadcastPush(message)
+    }
+  }
+
+  private _encodeBinaryUserBroadcastPush(message: Msg<{ event: string } & { [key: string]: any }>) {
+    const userPayload = message.payload?.payload ?? new ArrayBuffer(0)
+    return this._encodeUserBroadcastPush(message, this.BINARY_ENCODING, userPayload)
+  }
+
+  private _encodeJsonUserBroadcastPush(message: Msg<{ event: string } & { [key: string]: any }>) {
+    const userPayload = message.payload?.payload ?? {}
+    const encoder = new TextEncoder()
+    const encodedUserPayload = encoder.encode(JSON.stringify(userPayload)).buffer
+    return this._encodeUserBroadcastPush(message, this.JSON_ENCODING, encodedUserPayload)
+  }
+
+  private _encodeUserBroadcastPush(
+    message: Msg<{ event: string } & { [key: string]: any }>,
+    encodingType: number,
+    encodedPayload: ArrayBuffer
+  ) {
+    const topic = message.topic
+    const ref = message.ref ?? ''
+    const joinRef = message.join_ref ?? ''
+    const userEvent = message.payload.event
+
+    // Filter metadata based on allowed keys
+    const rest = this.allowedMetadataKeys
+      ? this._pick(message.payload, this.allowedMetadataKeys)
+      : {}
+
+    const metadata = Object.keys(rest).length === 0 ? '' : JSON.stringify(rest)
+
+    // Validate lengths don't exceed uint8 max value (255)
+    if (joinRef.length > 255) {
+      throw new Error(`joinRef length ${joinRef.length} exceeds maximum of 255`)
+    }
+    if (ref.length > 255) {
+      throw new Error(`ref length ${ref.length} exceeds maximum of 255`)
+    }
+    if (topic.length > 255) {
+      throw new Error(`topic length ${topic.length} exceeds maximum of 255`)
+    }
+    if (userEvent.length > 255) {
+      throw new Error(`userEvent length ${userEvent.length} exceeds maximum of 255`)
+    }
+    if (metadata.length > 255) {
+      throw new Error(`metadata length ${metadata.length} exceeds maximum of 255`)
+    }
+
+    const metaLength =
+      this.USER_BROADCAST_PUSH_META_LENGTH +
+      joinRef.length +
+      ref.length +
+      topic.length +
+      userEvent.length +
+      metadata.length
+
+    const header = new ArrayBuffer(this.HEADER_LENGTH + metaLength)
+    let view = new DataView(header)
+    let offset = 0
+
+    view.setUint8(offset++, this.KINDS.userBroadcastPush) // kind
+    view.setUint8(offset++, joinRef.length)
+    view.setUint8(offset++, ref.length)
+    view.setUint8(offset++, topic.length)
+    view.setUint8(offset++, userEvent.length)
+    view.setUint8(offset++, metadata.length)
+    view.setUint8(offset++, encodingType)
+    Array.from(joinRef, (char) => view.setUint8(offset++, char.charCodeAt(0)))
+    Array.from(ref, (char) => view.setUint8(offset++, char.charCodeAt(0)))
+    Array.from(topic, (char) => view.setUint8(offset++, char.charCodeAt(0)))
+    Array.from(userEvent, (char) => view.setUint8(offset++, char.charCodeAt(0)))
+    Array.from(metadata, (char) => view.setUint8(offset++, char.charCodeAt(0)))
+
+    var combined = new Uint8Array(header.byteLength + encodedPayload.byteLength)
+    combined.set(new Uint8Array(header), 0)
+    combined.set(new Uint8Array(encodedPayload), header.byteLength)
+
+    return combined.buffer
+  }
+
+  decode(rawPayload: ArrayBuffer | string, callback: Function) {
+    if (this._isArrayBuffer(rawPayload)) {
+      let result = this._binaryDecode(rawPayload as ArrayBuffer)
+      return callback(result)
+    }
+
+    if (typeof rawPayload === 'string') {
+      const jsonPayload = JSON.parse(rawPayload)
+      const [join_ref, ref, topic, event, payload] = jsonPayload
+      return callback({ join_ref, ref, topic, event, payload })
+    }
+
+    return callback({})
+  }
+
+  private _binaryDecode(buffer: ArrayBuffer) {
+    const view = new DataView(buffer)
+    const kind = view.getUint8(0)
+    const decoder = new TextDecoder()
+    switch (kind) {
+      case this.KINDS.userBroadcast:
+        return this._decodeUserBroadcast(buffer, view, decoder)
+    }
+  }
+
+  private _decodeUserBroadcast(
+    buffer: ArrayBuffer,
+    view: DataView,
+    decoder: TextDecoder
+  ): {
+    join_ref: null
+    ref: null
+    topic: string
+    event: string
+    payload: { [key: string]: any }
+  } {
+    const topicSize = view.getUint8(1)
+    const userEventSize = view.getUint8(2)
+    const metadataSize = view.getUint8(3)
+    const payloadEncoding = view.getUint8(4)
+
+    let offset = this.HEADER_LENGTH + 4
+    const topic = decoder.decode(buffer.slice(offset, offset + topicSize))
+    offset = offset + topicSize
+    const userEvent = decoder.decode(buffer.slice(offset, offset + userEventSize))
+    offset = offset + userEventSize
+    const metadata = decoder.decode(buffer.slice(offset, offset + metadataSize))
+    offset = offset + metadataSize
+
+    const payload = buffer.slice(offset, buffer.byteLength)
+    const parsedPayload =
+      payloadEncoding === this.JSON_ENCODING ? JSON.parse(decoder.decode(payload)) : payload
+
+    const data: { [key: string]: any } = {
+      type: this.BROADCAST_EVENT,
+      event: userEvent,
+      payload: parsedPayload,
+    }
+
+    // Metadata is optional and always JSON encoded
+    if (metadataSize > 0) {
+      data['meta'] = JSON.parse(metadata)
+    }
+
+    return { join_ref: null, ref: null, topic: topic, event: this.BROADCAST_EVENT, payload: data }
+  }
+
+  private _isArrayBuffer(buffer: any): boolean {
+    return buffer instanceof ArrayBuffer || buffer?.constructor?.name === 'ArrayBuffer'
+  }
+
+  private _pick(obj: Record<string, any> | null | undefined, keys: string[]): Record<string, any> {
+    if (!obj || typeof obj !== 'object') {
+      return {}
+    }
+    return Object.fromEntries(Object.entries(obj).filter(([key]) => keys.includes(key)))
+  }
+}

package/templates/realtime-agent/node_modules/@supabase/realtime-js/src/lib/transformers.ts

@@ -0,0 +1,270 @@
+/**
+ * Helpers to convert the change Payload into native JS types.
+ */
+
+// Adapted from epgsql (src/epgsql_binary.erl), this module licensed under
+// 3-clause BSD found here: https://raw.githubusercontent.com/epgsql/epgsql/devel/LICENSE
+
+export enum PostgresTypes {
+  abstime = 'abstime',
+  bool = 'bool',
+  date = 'date',
+  daterange = 'daterange',
+  float4 = 'float4',
+  float8 = 'float8',
+  int2 = 'int2',
+  int4 = 'int4',
+  int4range = 'int4range',
+  int8 = 'int8',
+  int8range = 'int8range',
+  json = 'json',
+  jsonb = 'jsonb',
+  money = 'money',
+  numeric = 'numeric',
+  oid = 'oid',
+  reltime = 'reltime',
+  text = 'text',
+  time = 'time',
+  timestamp = 'timestamp',
+  timestamptz = 'timestamptz',
+  timetz = 'timetz',
+  tsrange = 'tsrange',
+  tstzrange = 'tstzrange',
+}
+
+type Columns = {
+  name: string // the column name. eg: "user_id"
+  type: string // the column type. eg: "uuid"
+  flags?: string[] // any special flags for the column. eg: ["key"]
+  type_modifier?: number // the type modifier. eg: 4294967295
+}[]
+
+type BaseValue = null | string | number | boolean
+type RecordValue = BaseValue | BaseValue[]
+
+type Record = {
+  [key: string]: RecordValue
+}
+
+/**
+ * Takes an array of columns and an object of string values then converts each string value
+ * to its mapped type.
+ *
+ * @param {{name: String, type: String}[]} columns
+ * @param {Object} record
+ * @param {Object} options The map of various options that can be applied to the mapper
+ * @param {Array} options.skipTypes The array of types that should not be converted
+ *
+ * @example convertChangeData([{name: 'first_name', type: 'text'}, {name: 'age', type: 'int4'}], {first_name: 'Paul', age:'33'}, {})
+ * //=>{ first_name: 'Paul', age: 33 }
+ */
+export const convertChangeData = (
+  columns: Columns,
+  record: Record | null,
+  options: { skipTypes?: string[] } = {}
+): Record => {
+  const skipTypes = options.skipTypes ?? []
+
+  if (!record) {
+    return {}
+  }
+
+  return Object.keys(record).reduce((acc, rec_key) => {
+    acc[rec_key] = convertColumn(rec_key, columns, record, skipTypes)
+    return acc
+  }, {} as Record)
+}
+
+/**
+ * Converts the value of an individual column.
+ *
+ * @param {String} columnName The column that you want to convert
+ * @param {{name: String, type: String}[]} columns All of the columns
+ * @param {Object} record The map of string values
+ * @param {Array} skipTypes An array of types that should not be converted
+ * @return {object} Useless information
+ *
+ * @example convertColumn('age', [{name: 'first_name', type: 'text'}, {name: 'age', type: 'int4'}], {first_name: 'Paul', age: '33'}, [])
+ * //=> 33
+ * @example convertColumn('age', [{name: 'first_name', type: 'text'}, {name: 'age', type: 'int4'}], {first_name: 'Paul', age: '33'}, ['int4'])
+ * //=> "33"
+ */
+export const convertColumn = (
+  columnName: string,
+  columns: Columns,
+  record: Record,
+  skipTypes: string[]
+): RecordValue => {
+  const column = columns.find((x) => x.name === columnName)
+  const colType = column?.type
+  const value = record[columnName]
+
+  if (colType && !skipTypes.includes(colType)) {
+    return convertCell(colType, value)
+  }
+
+  return noop(value)
+}
+
+/**
+ * If the value of the cell is `null`, returns null.
+ * Otherwise converts the string value to the correct type.
+ * @param {String} type A postgres column type
+ * @param {String} value The cell value
+ *
+ * @example convertCell('bool', 't')
+ * //=> true
+ * @example convertCell('int8', '10')
+ * //=> 10
+ * @example convertCell('_int4', '{1,2,3,4}')
+ * //=> [1,2,3,4]
+ */
+export const convertCell = (type: string, value: RecordValue): RecordValue => {
+  // if data type is an array
+  if (type.charAt(0) === '_') {
+    const dataType = type.slice(1, type.length)
+    return toArray(value, dataType)
+  }
+
+  // If not null, convert to correct type.
+  switch (type) {
+    case PostgresTypes.bool:
+      return toBoolean(value)
+    case PostgresTypes.float4:
+    case PostgresTypes.float8:
+    case PostgresTypes.int2:
+    case PostgresTypes.int4:
+    case PostgresTypes.int8:
+    case PostgresTypes.numeric:
+    case PostgresTypes.oid:
+      return toNumber(value)
+    case PostgresTypes.json:
+    case PostgresTypes.jsonb:
+      return toJson(value)
+    case PostgresTypes.timestamp:
+      return toTimestampString(value) // Format to be consistent with PostgREST
+    case PostgresTypes.abstime: // To allow users to cast it based on Timezone
+    case PostgresTypes.date: // To allow users to cast it based on Timezone
+    case PostgresTypes.daterange:
+    case PostgresTypes.int4range:
+    case PostgresTypes.int8range:
+    case PostgresTypes.money:
+    case PostgresTypes.reltime: // To allow users to cast it based on Timezone
+    case PostgresTypes.text:
+    case PostgresTypes.time: // To allow users to cast it based on Timezone
+    case PostgresTypes.timestamptz: // To allow users to cast it based on Timezone
+    case PostgresTypes.timetz: // To allow users to cast it based on Timezone
+    case PostgresTypes.tsrange:
+    case PostgresTypes.tstzrange:
+      return noop(value)
+    default:
+      // Return the value for remaining types
+      return noop(value)
+  }
+}
+
+const noop = (value: RecordValue): RecordValue => {
+  return value
+}
+export const toBoolean = (value: RecordValue): RecordValue => {
+  switch (value) {
+    case 't':
+      return true
+    case 'f':
+      return false
+    default:
+      return value
+  }
+}
+export const toNumber = (value: RecordValue): RecordValue => {
+  if (typeof value === 'string') {
+    const parsedValue = parseFloat(value)
+    if (!Number.isNaN(parsedValue)) {
+      return parsedValue
+    }
+  }
+  return value
+}
+export const toJson = (value: RecordValue): RecordValue => {
+  if (typeof value === 'string') {
+    try {
+      return JSON.parse(value)
+    } catch {
+      return value
+    }
+  }
+  return value
+}
+
+/**
+ * Converts a Postgres Array into a native JS array
+ *
+ * @example toArray('{}', 'int4')
+ * //=> []
+ * @example toArray('{"[2021-01-01,2021-12-31)","(2021-01-01,2021-12-32]"}', 'daterange')
+ * //=> ['[2021-01-01,2021-12-31)', '(2021-01-01,2021-12-32]']
+ * @example toArray([1,2,3,4], 'int4')
+ * //=> [1,2,3,4]
+ */
+export const toArray = (value: RecordValue, type: string): RecordValue => {
+  if (typeof value !== 'string') {
+    return value
+  }
+
+  const lastIdx = value.length - 1
+  const closeBrace = value[lastIdx]
+  const openBrace = value[0]
+
+  // Confirm value is a Postgres array by checking curly brackets
+  if (openBrace === '{' && closeBrace === '}') {
+    let arr
+    const valTrim = value.slice(1, lastIdx)
+
+    // TODO: find a better solution to separate Postgres array data
+    try {
+      arr = JSON.parse('[' + valTrim + ']')
+    } catch (_) {
+      // WARNING: splitting on comma does not cover all edge cases
+      arr = valTrim ? valTrim.split(',') : []
+    }
+
+    return arr.map((val: BaseValue) => convertCell(type, val))
+  }
+
+  return value
+}
+
+/**
+ * Fixes timestamp to be ISO-8601. Swaps the space between the date and time for a 'T'
+ * See https://github.com/supabase/supabase/issues/18
+ *
+ * @example toTimestampString('2019-09-10 00:00:00')
+ * //=> '2019-09-10T00:00:00'
+ */
+export const toTimestampString = (value: RecordValue): RecordValue => {
+  if (typeof value === 'string') {
+    return value.replace(' ', 'T')
+  }
+
+  return value
+}
+
+export const httpEndpointURL = (socketUrl: string): string => {
+  const wsUrl = new URL(socketUrl)
+
+  wsUrl.protocol = wsUrl.protocol.replace(/^ws/i, 'http')
+
+  wsUrl.pathname = wsUrl.pathname
+    .replace(/\/+$/, '') // remove all trailing slashes
+    .replace(/\/socket\/websocket$/i, '') // remove the socket/websocket path
+    .replace(/\/socket$/i, '') // remove the socket path
+    .replace(/\/websocket$/i, '') // remove the websocket path
+
+  if (wsUrl.pathname === '' || wsUrl.pathname === '/') {
+    wsUrl.pathname = '/api/broadcast'
+  } else {
+    wsUrl.pathname = wsUrl.pathname + '/api/broadcast'
+  }
+
+  return wsUrl.href
+}

package/templates/realtime-agent/node_modules/@supabase/realtime-js/src/lib/version.ts

@@ -0,0 +1,7 @@
+// Generated automatically during releases by scripts/update-version-files.ts
+// This file provides runtime access to the package version for:
+// - HTTP request headers (e.g., X-Client-Info header for API requests)
+// - Debugging and support (identifying which version is running)
+// - Telemetry and logging (version reporting in errors/analytics)
+// - Ensuring build artifacts match the published package version
+export const version = '2.105.4'