livekit-client 2.3.2 → 2.4.0

package/dist/ts4.2/src/room/participant/LocalParticipant.d.ts

@@ -26,6 +26,7 @@ export default class LocalParticipant extends Participant {
     private roomOptions;
     private encryptionType;
     private reconnectFuture?;
+    private pendingSignalRequests;
     /** @internal */
     constructor(sid: string, identity: string, engine: RTCEngine, options: InternalRoomOptions);
     get lastCameraError(): Error | undefined;
@@ -40,22 +41,29 @@ export default class LocalParticipant extends Participant {
     private handleReconnecting;
     private handleReconnected;
     private handleDisconnected;
+    private handleSignalRequestError;
     /**
      * Sets and updates the metadata of the local participant.
-     * The change does not take immediate effect.
-     * If successful, a `ParticipantEvent.MetadataChanged` event will be emitted on the local participant.
      * Note: this requires `canUpdateOwnMetadata` permission.
+     * method will throw if the user doesn't have the required permissions
      * @param metadata
      */
-    setMetadata(metadata: string): void;
+    setMetadata(metadata: string): Promise<void>;
     /**
      * Sets and updates the name of the local participant.
-     * The change does not take immediate effect.
-     * If successful, a `ParticipantEvent.ParticipantNameChanged` event will be emitted on the local participant.
      * Note: this requires `canUpdateOwnMetadata` permission.
+     * method will throw if the user doesn't have the required permissions
      * @param metadata
      */
-    setName(name: string): void;
+    setName(name: string): Promise<void>;
+    /**
+     * Set or update participant attributes. It will make updates only to keys that
+     * are present in `attributes`, and will not override others.
+     * Note: this requires `canUpdateOwnMetadata` permission.
+     * @param attributes attributes to update
+     */
+    setAttributes(attributes: Record<string, string>): Promise<void>;
+    private requestMetadataUpdate;
     /**
      * Enable or disable a participant's camera track.
      *

package/dist/ts4.2/src/room/participant/Participant.d.ts

@@ -39,6 +39,7 @@ export default class Participant extends Participant_base {
     name?: string;
     /** client metadata, opaque to livekit */
     metadata?: string;
+    private _attributes;
     lastSpokeAt?: Date | undefined;
     permissions?: ParticipantPermission;
     protected _kind: ParticipantKind;
@@ -52,6 +53,8 @@ export default class Participant extends Participant_base {
     get isEncrypted(): boolean;
     get isAgent(): boolean;
     get kind(): ParticipantKind;
+    /** participant attributes, similar to metadata, but as a key/value map */
+    get attributes(): Readonly<Record<string, string>>;
     /** @internal */
     constructor(sid: string, identity: string, name?: string, metadata?: string, loggerOptions?: LoggerOptions, kind?: ParticipantKind);
     getTrackPublications(): TrackPublication[];
@@ -78,6 +81,10 @@ export default class Participant extends Participant_base {
      **/
     private _setMetadata;
     private _setName;
+    /**
+     * Updates metadata from server
+     **/
+    private _setAttributes;
     /** @internal */
     setPermissions(permissions: ParticipantPermission): boolean;
     /** @internal */
@@ -113,5 +120,6 @@ export type ParticipantEventCallbacks = {
     audioStreamAcquired: () => void;
     participantPermissionsChanged: (prevPermissions?: ParticipantPermission) => void;
     trackSubscriptionStatusChanged: (publication: RemoteTrackPublication, status: TrackPublication.SubscriptionStatus) => void;
+    attributesChanged: (changedAttributes: Record<string, string>) => void;
 };
 //# sourceMappingURL=Participant.d.ts.map

package/dist/ts4.2/src/room/timers.d.ts

@@ -4,9 +4,9 @@
  * that the timer fires on time.
  */
 export default class CriticalTimers {
-    static setTimeout: (handler: TimerHandler, timeout?: number | undefined, ...arguments: any[]) => number;
-    static setInterval: (handler: TimerHandler, timeout?: number | undefined, ...arguments: any[]) => number;
-    static clearTimeout: (id: number | undefined) => void;
-    static clearInterval: (id: number | undefined) => void;
+    static setTimeout: (callback: (args: void) => void, ms?: number | undefined) => NodeJS.Timeout;
+    static setInterval: (callback: (args: void) => void, ms?: number | undefined) => NodeJS.Timeout;
+    static clearTimeout: (timeoutId: string | number | NodeJS.Timeout | undefined) => void;
+    static clearInterval: (intervalId: string | number | NodeJS.Timeout | undefined) => void;
 }
 //# sourceMappingURL=timers.d.ts.map

package/dist/ts4.2/src/room/track/utils.d.ts

@@ -30,4 +30,5 @@ export declare function mimeTypeToVideoCodecString(mimeType: string): "vp8" | "h
 export declare function getTrackPublicationInfo<T extends TrackPublication>(tracks: T[]): TrackPublishedResponse[];
 export declare function getLogContextFromTrack(track: Track | TrackPublication): Record<string, unknown>;
 export declare function supportsSynchronizationSources(): boolean;
+export declare function diffAttributes(oldValues: Record<string, string> | undefined, newValues: Record<string, string> | undefined): Record<string, string>;
 //# sourceMappingURL=utils.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livekit-client",
-  "version": "2.3.2",
+  "version": "2.4.0",
   "description": "JavaScript/TypeScript client SDK for LiveKit",
   "main": "./dist/livekit-client.umd.js",
   "unpkg": "./dist/livekit-client.umd.js",
@@ -36,7 +36,7 @@
   "author": "David Zhao <david@davidzhao.com>",
   "license": "Apache-2.0",
   "dependencies": {
-    "@livekit/protocol": "1.19.0",
+    "@livekit/protocol": "1.19.1",
     "events": "^3.3.0",
     "loglevel": "^1.8.0",
     "sdp-transform": "^2.14.1",

package/src/api/SignalClient.ts

@@ -4,6 +4,7 @@ import {
   ClientInfo,
   ConnectionQualityUpdate,
   DisconnectReason,
+  ErrorResponse,
   JoinResponse,
   LeaveRequest,
   LeaveRequest_Action,
@@ -141,6 +142,8 @@ export class SignalClient {
 
   onLeave?: (leave: LeaveRequest) => void;
 
+  onErrorResponse?: (error: ErrorResponse) => void;
+
   connectOptions?: ConnectOpts;
 
   ws?: WebSocket;
@@ -163,6 +166,11 @@ export class SignalClient {
     );
   }
 
+  private getNextRequestId() {
+    this._requestId += 1;
+    return this._requestId;
+  }
+
   private options?: SignalOptions;
 
   private pingTimeout: ReturnType<typeof setTimeout> | undefined;
@@ -183,6 +191,8 @@ export class SignalClient {
 
   private loggerContextCb?: LoggerOptions['loggerContextCb'];
 
+  private _requestId = 0;
+
   constructor(useJSON: boolean = false, loggerOptions: LoggerOptions = {}) {
     this.log = getLogger(loggerOptions.loggerName ?? LoggerNames.Signal);
     this.loggerContextCb = loggerOptions.loggerContextCb;
@@ -511,14 +521,22 @@ export class SignalClient {
     });
   }
 
-  sendUpdateLocalMetadata(metadata: string, name: string) {
-    return this.sendRequest({
+  async sendUpdateLocalMetadata(
+    metadata: string,
+    name: string,
+    attributes: Record<string, string> = {},
+  ) {
+    const requestId = this.getNextRequestId();
+    await this.sendRequest({
       case: 'updateMetadata',
       value: new UpdateParticipantMetadata({
+        requestId,
         metadata,
         name,
+        attributes,
       }),
     });
+    return requestId;
   }
 
   sendUpdateTrackSettings(settings: UpdateTrackSettings) {
@@ -721,6 +739,10 @@ export class SignalClient {
       this.rtt = Date.now() - Number.parseInt(msg.value.lastPingTimestamp.toString());
       this.resetPingTimeout();
       pingHandled = true;
+    } else if (msg.case === 'errorResponse') {
+      if (this.onErrorResponse) {
+        this.onErrorResponse(msg.value);
+      }
     } else {
       this.log.debug('unsupported message', { ...this.logContext, msgCase: msg.case });
     }

package/src/e2ee/errors.ts

@@ -9,8 +9,15 @@ export enum CryptorErrorReason {
 export class CryptorError extends LivekitError {
   reason: CryptorErrorReason;
 
-  constructor(message?: string, reason: CryptorErrorReason = CryptorErrorReason.InternalError) {
+  participantIdentity?: string;
+
+  constructor(
+    message?: string,
+    reason: CryptorErrorReason = CryptorErrorReason.InternalError,
+    participantIdentity?: string,
+  ) {
     super(40, message);
     this.reason = reason;
+    this.participantIdentity = participantIdentity;
   }
 }

package/src/e2ee/index.ts

@@ -2,3 +2,4 @@ export * from './KeyProvider';
 export * from './utils';
 export * from './types';
 export * from './events';
+export * from './errors';

package/src/e2ee/worker/FrameCryptor.ts

@@ -183,7 +183,12 @@ export class FrameCryptor extends BaseFrameCryptor {
       .pipeTo(writable)
       .catch((e) => {
         workerLogger.warn(e);
-        this.emit(CryptorEvent.Error, e instanceof CryptorError ? e : new CryptorError(e.message));
+        this.emit(
+          CryptorEvent.Error,
+          e instanceof CryptorError
+            ? e
+            : new CryptorError(e.message, undefined, this.participantIdentity),
+        );
       });
     this.trackId = trackId;
   }
@@ -294,10 +299,14 @@ export class FrameCryptor extends BaseFrameCryptor {
         workerLogger.error(e);
       }
     } else {
-      workerLogger.debug('failed to decrypt, emitting error', this.logContext);
+      workerLogger.debug('failed to encrypt, emitting error', this.logContext);
       this.emit(
         CryptorEvent.Error,
-        new CryptorError(`encryption key missing for encoding`, CryptorErrorReason.MissingKey),
+        new CryptorError(
+          `encryption key missing for encoding`,
+          CryptorErrorReason.MissingKey,
+          this.participantIdentity,
+        ),
       );
     }
   }
@@ -367,6 +376,7 @@ export class FrameCryptor extends BaseFrameCryptor {
         new CryptorError(
           `missing key at index ${keyIndex} for participant ${this.participantIdentity}`,
           CryptorErrorReason.MissingKey,
+          this.participantIdentity,
         ),
       );
     }
@@ -487,12 +497,14 @@ export class FrameCryptor extends BaseFrameCryptor {
           throw new CryptorError(
             `valid key missing for participant ${this.participantIdentity}`,
             CryptorErrorReason.InvalidKey,
+            this.participantIdentity,
           );
         }
       } else {
         throw new CryptorError(
           `Decryption failed: ${error.message}`,
           CryptorErrorReason.InvalidKey,
+          this.participantIdentity,
         );
       }
     }

package/src/logger.ts

@@ -54,9 +54,10 @@ export function getLogger(name: string) {
 export function setLogLevel(level: LogLevel | LogLevelString, loggerName?: LoggerNames) {
   if (loggerName) {
     log.getLogger(loggerName).setLevel(level);
-  }
-  for (const logger of livekitLoggers) {
-    logger.setLevel(level);
+  } else {
+    for (const logger of livekitLoggers) {
+      logger.setLevel(level);
+    }
   }
 }
 

package/src/room/DeviceManager.ts

@@ -41,7 +41,7 @@ export default class DeviceManager {
       !(isSafari() && this.hasDeviceInUse(kind))
     ) {
       const isDummyDeviceOrEmpty =
-        devices.length === 0 ||
+        devices.filter((d) => d.kind === kind).length === 0 ||
         devices.some((device) => {
           const noLabel = device.label === '';
           const isRelevant = kind ? device.kind === kind : true;

package/src/room/RTCEngine.ts

@@ -7,6 +7,7 @@ import {
   DataPacket,
   DataPacket_Kind,
   DisconnectReason,
+  ErrorResponse,
   type JoinResponse,
   type LeaveRequest,
   LeaveRequest_Action,
@@ -193,6 +194,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       this.emit(EngineEvent.SubscriptionPermissionUpdate, update);
     this.client.onSpeakersChanged = (update) => this.emit(EngineEvent.SpeakersChanged, update);
     this.client.onStreamStateUpdate = (update) => this.emit(EngineEvent.StreamStateChanged, update);
+    this.client.onErrorResponse = (error) => this.emit(EngineEvent.SignalRequestError, error);
   }
 
   /** @internal */
@@ -1412,6 +1414,7 @@ export type EngineEventCallbacks = {
   localTrackUnpublished: (unpublishedResponse: TrackUnpublishedResponse) => void;
   remoteMute: (trackSid: string, muted: boolean) => void;
   offline: () => void;
+  signalRequestError: (error: ErrorResponse) => void;
 };
 
 function supportOptionalDatachannel(protocol: number | undefined): boolean {

package/src/room/Room.ts

@@ -2131,6 +2131,10 @@ export type RoomEventCallbacks = {
     prevPermissions: ParticipantPermission | undefined,
     participant: RemoteParticipant | LocalParticipant,
   ) => void;
+  participantAttributesChanged: (
+    changedAttributes: Record<string, string>,
+    participant: RemoteParticipant | LocalParticipant,
+  ) => void;
   activeSpeakersChanged: (speakers: Array<Participant>) => void;
   roomMetadataChanged: (metadata: string) => void;
   dataReceived: (

package/src/room/errors.ts

@@ -1,3 +1,5 @@
+import { ErrorResponse_Reason } from '@livekit/protocol';
+
 export class LivekitError extends Error {
   code: number;
 
@@ -63,6 +65,15 @@ export class PublishDataError extends LivekitError {
   }
 }
 
+export class SignalRequestError extends LivekitError {
+  reason: ErrorResponse_Reason;
+
+  constructor(message: string, reason: ErrorResponse_Reason = ErrorResponse_Reason.UNKNOWN) {
+    super(15, message);
+    this.reason = reason;
+  }
+}
+
 export enum MediaDeviceFailure {
   // user rejected permissions
   PermissionDenied = 'PermissionDenied',

package/src/room/events.ts

@@ -185,6 +185,13 @@ export enum RoomEvent {
    */
   ParticipantNameChanged = 'participantNameChanged',
 
+  /**
+   * Participant attributes is an app-specific key value state to be pushed to
+   * all users.
+   * When a participant's attributes changed, this event will be emitted with the changed attributes and the participant
+   */
+  ParticipantAttributesChanged = 'participantAttributesChanged',
+
   /**
    * Room metadata is a simple way for app-specific state to be pushed to
    * all users.
@@ -495,6 +502,13 @@ export enum ParticipantEvent {
 
   /** @internal */
   PCTrackAdded = 'pcTrackAdded',
+
+  /**
+   * Participant attributes is an app-specific key value state to be pushed to
+   * all users.
+   * When a participant's attributes changed, this event will be emitted with the changed attributes
+   */
+  AttributesChanged = 'attributesChanged',
 }
 
 /** @internal */
@@ -525,6 +539,7 @@ export enum EngineEvent {
   SubscribedQualityUpdate = 'subscribedQualityUpdate',
   LocalTrackUnpublished = 'localTrackUnpublished',
   Offline = 'offline',
+  SignalRequestError = 'signalRequestError',
 }
 
 export enum TrackEvent {

package/src/room/participant/LocalParticipant.ts

@@ -3,6 +3,7 @@ import {
   DataPacket,
   DataPacket_Kind,
   Encryption_Type,
+  ErrorResponse,
   ParticipantInfo,
   ParticipantPermission,
   SimulcastCodec,
@@ -14,7 +15,13 @@ import type { InternalRoomOptions } from '../../options';
 import { PCTransportState } from '../PCTransportManager';
 import type RTCEngine from '../RTCEngine';
 import { defaultVideoCodec } from '../defaults';
-import { DeviceUnsupportedError, TrackInvalidError, UnexpectedConnectionState } from '../errors';
+import {
+  DeviceUnsupportedError,
+  LivekitError,
+  SignalRequestError,
+  TrackInvalidError,
+  UnexpectedConnectionState,
+} from '../errors';
 import { EngineEvent, ParticipantEvent, TrackEvent } from '../events';
 import LocalAudioTrack from '../track/LocalAudioTrack';
 import LocalTrack from '../track/LocalTrack';
@@ -46,6 +53,7 @@ import {
   isSVCCodec,
   isSafari17,
   isWeb,
+  sleep,
   supportsAV1,
   supportsVP9,
 } from '../utils';
@@ -92,6 +100,15 @@ export default class LocalParticipant extends Participant {
 
   private reconnectFuture?: Future<void>;
 
+  private pendingSignalRequests: Map<
+    number,
+    {
+      resolve: (arg: any) => void;
+      reject: (reason: LivekitError) => void;
+      values: Partial<Record<keyof LocalParticipant, any>>;
+    }
+  >;
+
   /** @internal */
   constructor(sid: string, identity: string, engine: RTCEngine, options: InternalRoomOptions) {
     super(sid, identity, undefined, undefined, {
@@ -105,6 +122,7 @@ export default class LocalParticipant extends Participant {
     this.roomOptions = options;
     this.setupEngine(engine);
     this.activeDeviceMap = new Map();
+    this.pendingSignalRequests = new Map();
   }
 
   get lastCameraError(): Error | undefined {
@@ -158,7 +176,8 @@ export default class LocalParticipant extends Participant {
       .on(EngineEvent.Resuming, this.handleReconnecting)
       .on(EngineEvent.LocalTrackUnpublished, this.handleLocalTrackUnpublished)
       .on(EngineEvent.SubscribedQualityUpdate, this.handleSubscribedQualityUpdate)
-      .on(EngineEvent.Disconnected, this.handleDisconnected);
+      .on(EngineEvent.Disconnected, this.handleDisconnected)
+      .on(EngineEvent.SignalRequestError, this.handleSignalRequestError);
   }
 
   private handleReconnecting = () => {
@@ -181,26 +200,89 @@ export default class LocalParticipant extends Participant {
     }
   };
 
+  private handleSignalRequestError = (error: ErrorResponse) => {
+    const { requestId, reason, message } = error;
+    const failedRequest = this.pendingSignalRequests.get(requestId);
+    if (failedRequest) {
+      failedRequest.reject(new SignalRequestError(message, reason));
+      this.pendingSignalRequests.delete(requestId);
+    }
+  };
+
   /**
    * Sets and updates the metadata of the local participant.
-   * The change does not take immediate effect.
-   * If successful, a `ParticipantEvent.MetadataChanged` event will be emitted on the local participant.
    * Note: this requires `canUpdateOwnMetadata` permission.
+   * method will throw if the user doesn't have the required permissions
    * @param metadata
    */
-  setMetadata(metadata: string): void {
-    this.engine.client.sendUpdateLocalMetadata(metadata, this.name ?? '');
+  async setMetadata(metadata: string): Promise<void> {
+    await this.requestMetadataUpdate({ metadata });
   }
 
   /**
    * Sets and updates the name of the local participant.
-   * The change does not take immediate effect.
-   * If successful, a `ParticipantEvent.ParticipantNameChanged` event will be emitted on the local participant.
    * Note: this requires `canUpdateOwnMetadata` permission.
+   * method will throw if the user doesn't have the required permissions
    * @param metadata
    */
-  setName(name: string): void {
-    this.engine.client.sendUpdateLocalMetadata(this.metadata ?? '', name);
+  async setName(name: string): Promise<void> {
+    await this.requestMetadataUpdate({ name });
+  }
+
+  /**
+   * Set or update participant attributes. It will make updates only to keys that
+   * are present in `attributes`, and will not override others.
+   * Note: this requires `canUpdateOwnMetadata` permission.
+   * @param attributes attributes to update
+   */
+  async setAttributes(attributes: Record<string, string>) {
+    await this.requestMetadataUpdate({ attributes });
+  }
+
+  private async requestMetadataUpdate({
+    metadata,
+    name,
+    attributes,
+  }: {
+    metadata?: string;
+    name?: string;
+    attributes?: Record<string, string>;
+  }) {
+    return new Promise<void>(async (resolve, reject) => {
+      try {
+        let isRejected = false;
+        const requestId = await this.engine.client.sendUpdateLocalMetadata(
+          metadata ?? this.metadata ?? '',
+          name ?? this.name ?? '',
+          attributes,
+        );
+        const startTime = performance.now();
+        this.pendingSignalRequests.set(requestId, {
+          resolve,
+          reject: (error: LivekitError) => {
+            reject(error);
+            isRejected = true;
+          },
+          values: { name, metadata, attributes },
+        });
+        while (performance.now() - startTime < 5_000 && !isRejected) {
+          if (
+            (!name || this.name === name) &&
+            (!metadata || this.metadata === metadata) &&
+            (!attributes ||
+              Object.entries(attributes).every(([key, value]) => this.attributes[key] === value))
+          ) {
+            this.pendingSignalRequests.delete(requestId);
+            resolve();
+            return;
+          }
+          await sleep(50);
+        }
+        reject(new SignalRequestError('Request to update local metadata timed out'));
+      } catch (e: any) {
+        if (e instanceof Error) reject(e);
+      }
+    });
   }
 
   /**

package/src/room/participant/Participant.ts

@@ -18,6 +18,7 @@ import type RemoteTrack from '../track/RemoteTrack';
 import type RemoteTrackPublication from '../track/RemoteTrackPublication';
 import { Track } from '../track/Track';
 import type { TrackPublication } from '../track/TrackPublication';
+import { diffAttributes } from '../track/utils';
 import type { LoggerOptions, TranscriptionSegment } from '../types';
 
 export enum ConnectionQuality {
@@ -77,6 +78,8 @@ export default class Participant extends (EventEmitter as new () => TypedEmitter
   /** client metadata, opaque to livekit */
   metadata?: string;
 
+  private _attributes: Record<string, string>;
+
   lastSpokeAt?: Date | undefined;
 
   permissions?: ParticipantPermission;
@@ -112,6 +115,11 @@ export default class Participant extends (EventEmitter as new () => TypedEmitter
     return this._kind;
   }
 
+  /** participant attributes, similar to metadata, but as a key/value map */
+  get attributes(): Readonly<Record<string, string>> {
+    return Object.freeze({ ...this._attributes });
+  }
+
   /** @internal */
   constructor(
     sid: string,
@@ -135,6 +143,7 @@ export default class Participant extends (EventEmitter as new () => TypedEmitter
     this.videoTrackPublications = new Map();
     this.trackPublications = new Map();
     this._kind = kind;
+    this._attributes = {};
   }
 
   getTrackPublications(): TrackPublication[] {
@@ -214,6 +223,7 @@ export default class Participant extends (EventEmitter as new () => TypedEmitter
     this.sid = info.sid;
     this._setName(info.name);
     this._setMetadata(info.metadata);
+    this._setAttributes(info.attributes);
     if (info.permission) {
       this.setPermissions(info.permission);
     }
@@ -245,6 +255,18 @@ export default class Participant extends (EventEmitter as new () => TypedEmitter
     }
   }
 
+  /**
+   * Updates metadata from server
+   **/
+  private _setAttributes(attributes: Record<string, string>) {
+    const diff = diffAttributes(attributes, this.attributes);
+    this._attributes = attributes;
+
+    if (Object.keys(diff).length > 0) {
+      this.emit(ParticipantEvent.AttributesChanged, diff);
+    }
+  }
+
   /** @internal */
   setPermissions(permissions: ParticipantPermission): boolean {
     const prevPermissions = this.permissions;
@@ -363,4 +385,5 @@ export type ParticipantEventCallbacks = {
     publication: RemoteTrackPublication,
     status: TrackPublication.SubscriptionStatus,
   ) => void;
+  attributesChanged: (changedAttributes: Record<string, string>) => void;
 };

package/src/room/track/utils.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import { AudioCaptureOptions, VideoCaptureOptions, VideoPresets } from './options';
-import { constraintsForOptions, mergeDefaultOptions } from './utils';
+import { constraintsForOptions, diffAttributes, mergeDefaultOptions } from './utils';
 
 describe('mergeDefaultOptions', () => {
   const audioDefaults: AudioCaptureOptions = {
@@ -109,3 +109,37 @@ describe('constraintsForOptions', () => {
     expect(videoOpts.aspectRatio).toEqual(VideoPresets.h720.resolution.aspectRatio);
   });
 });
+
+describe('diffAttributes', () => {
+  it('detects changed values', () => {
+    const oldValues: Record<string, string> = { a: 'value', b: 'initial', c: 'value' };
+    const newValues: Record<string, string> = { a: 'value', b: 'updated', c: 'value' };
+
+    const diff = diffAttributes(oldValues, newValues);
+    expect(Object.keys(diff).length).toBe(1);
+    expect(diff.b).toBe('updated');
+  });
+  it('detects new values', () => {
+    const newValues: Record<string, string> = { a: 'value', b: 'value', c: 'value' };
+    const oldValues: Record<string, string> = { a: 'value', b: 'value' };
+
+    const diff = diffAttributes(oldValues, newValues);
+    expect(Object.keys(diff).length).toBe(1);
+    expect(diff.c).toBe('value');
+  });
+  it('detects deleted values as empty strings', () => {
+    const newValues: Record<string, string> = { a: 'value', b: 'value' };
+    const oldValues: Record<string, string> = { a: 'value', b: 'value', c: 'value' };
+
+    const diff = diffAttributes(oldValues, newValues);
+    expect(Object.keys(diff).length).toBe(1);
+    expect(diff.c).toBe('');
+  });
+  it('compares with undefined values', () => {
+    const newValues: Record<string, string> = { a: 'value', b: 'value' };
+
+    const diff = diffAttributes(undefined, newValues);
+    expect(Object.keys(diff).length).toBe(2);
+    expect(diff.a).toBe('value');
+  });
+});