@bobfrankston/lxlan 0.1.13 → 0.1.16

package/.hintrc

@@ -28,6 +28,7 @@
       {
         "label": "off"
       }
-    ]
+    ],
+    "typescript-config/strict": "off"
   }
 }

package/README.md

@@ -127,8 +127,13 @@ client.on('device', (device) => {
   // New device discovered
 });
 
-client.on('state', (device) => {
+client.on('state', (device, info) => {
   // Device state updated
+  // info.primary = true if direct response from device
+  // info.primary = false if received via peer client broadcast
+  if (info.primary) {
+    console.log('Direct update from device');
+  }
 });
 
 client.on('deviceInfo', (device) => {
@@ -141,10 +146,22 @@ client.on('deviceInfo', (device) => {
 
 - `@bobfrankston/colorlib` - Color space conversions (HSB ↔ RGB ↔ Kelvin)
 
+## Keeping Transport Packages in Sync
+
+**IMPORTANT:** `lxlan-browser` and `lxlan-node` are parallel transport adapters. When modifying types or exports in this core package, ensure both adapters are updated if needed. They should expose equivalent functionality for their respective platforms.
+
+## Importing Types
+
+Types should be imported from this package using `import type`:
+
+```typescript
+import type { StateEventInfo, DeviceState } from '@bobfrankston/lxlan';
+```
+
 ## Related Packages
 
-- **[@bobfrankston/lxlan-node](../lxlan-node)** - Node.js transport wrapper
-- **[@bobfrankston/lxlan-browser](../lxlan-browser)** - Browser transport wrapper
+- **[@bobfrankston/lxlan-node](../lxlan-node)** - Node.js transport wrapper (keep in sync!)
+- **[@bobfrankston/lxlan-browser](../lxlan-browser)** - Browser transport wrapper (keep in sync!)
 - **[@bobfrankston/rmfudp](../../../../utils/udp/rmfudp)** - Node.js UDP transport
 - **[@bobfrankston/httpudp-client](../../../../utils/udp/httpudp-client)** - Browser WebSocket UDP client
 - **[@bobfrankston/httpudp](../../../../utils/udp/httpudp)** - WebSocket-to-UDP proxy server

package/client.d.ts

@@ -15,6 +15,8 @@ export interface LxClientOptions {
     discoveryInterval?: number;
     /** Enable client-to-client state broadcast for multi-client sync (default false) */
     clientBroadcastEnabled?: boolean;
+    /** Custom logger function (default: console.log) */
+    logger?: (msg: string, colors?: string) => void;
 }
 /**
  * LIFX LAN client for device discovery and control.
@@ -23,7 +25,7 @@ export interface LxClientOptions {
  * Events:
  * - `device` (device: LxDevice) - new device discovered
  * - `message` (device: LxDevice, msg: LxMessage) - any message received
- * - `state` (device: LxDevice) - light state updated
+ * - `state` (device: LxDevice, info: StateEventInfo) - light state updated (info.primary = true if from device, false if from peer broadcast)
  * - `power` (device: LxDevice) - power state updated
  * - `label` (device: LxDevice) - label updated
  * - `group` (device: LxDevice) - group info updated
@@ -41,7 +43,9 @@ export declare class LxClient {
     private transport;
     private port;
     private discoveryTimer?;
+    private discoveryIntervalMs;
     private clientBroadcastEnabled;
+    private log;
     /** Cached devices by MAC address (lowercase) */
     devices: Map<string, LxDevice>;
     constructor(options: LxClientOptions);
@@ -53,7 +57,7 @@ export declare class LxClient {
     off(event: string, listener: (...args: any[]) => void): this;
     /** Emit event */
     private emit;
-    /** Start listening */
+    /** Start listening and begin auto-discovery if configured */
     start(): Promise<void>;
     /** Stop and cleanup */
     stop(): void;

package/client.js

@@ -1,6 +1,6 @@
 import { hsbk16ToHsbk } from '@bobfrankston/colorlib';
 import { LxDevice } from './device.js';
-import { MessageType, LIFX_PORT } from './types.js';
+import { MessageType, LIFX_PORT, MessageTypeName } from './types.js';
 import { encodeMessage, decodeMessage, decodeState, decodeStatePower, decodeStateLabel, decodeStateVersion, decodeStateGroup, decodeStateService, decodeStateHostInfo, decodeStateHostFirmware, decodeStateWifiInfo, decodeStateInfo } from './protocol.js';
 /**
  * LIFX LAN client for device discovery and control.
@@ -9,7 +9,7 @@ import { encodeMessage, decodeMessage, decodeState, decodeStatePower, decodeStat
  * Events:
  * - `device` (device: LxDevice) - new device discovered
  * - `message` (device: LxDevice, msg: LxMessage) - any message received
- * - `state` (device: LxDevice) - light state updated
+ * - `state` (device: LxDevice, info: StateEventInfo) - light state updated (info.primary = true if from device, false if from peer broadcast)
  * - `power` (device: LxDevice) - power state updated
  * - `label` (device: LxDevice) - label updated
  * - `group` (device: LxDevice) - group info updated
@@ -27,7 +27,9 @@ export class LxClient {
     transport;
     port;
     discoveryTimer; // NodeJS.Timeout in Node, number in browser
+    discoveryIntervalMs;
     clientBroadcastEnabled;
+    log;
     /** Cached devices by MAC address (lowercase) */
     devices = new Map();
     constructor(options) {
@@ -35,6 +37,7 @@ export class LxClient {
         this.transport = options.transport;
         this.port = options.port ?? LIFX_PORT;
         this.clientBroadcastEnabled = options.clientBroadcastEnabled ?? false;
+        this.log = options.logger ?? ((msg, colors) => console.log(msg));
         this.transport.onMessage((data, rinfo) => {
             // Ensure data is Uint8Array for protocol decoder
             const buf = data instanceof Uint8Array ? data : new Uint8Array(data);
@@ -43,19 +46,7 @@ export class LxClient {
         this.transport.onError((err) => {
             this.emitter.emit('error', err);
         });
-        if (options.discoveryInterval && options.discoveryInterval > 0) {
-            this.discoveryTimer = setInterval(() => {
-                try {
-                    this.discover();
-                }
-                catch (err) {
-                    // Emit error but keep timer running
-                    if (err instanceof Error) {
-                        this.emitter.emit('error', err);
-                    }
-                }
-            }, options.discoveryInterval);
-        }
+        this.discoveryIntervalMs = options.discoveryInterval ?? 0;
     }
     /** Register event listener */
     on(event, listener) {
@@ -76,9 +67,19 @@ export class LxClient {
     emit(event, ...args) {
         return this.emitter.emit(event, ...args);
     }
-    /** Start listening */
+    /** Start listening and begin auto-discovery if configured */
     async start() {
         await this.transport.bind();
+        if (this.discoveryIntervalMs > 0 && !this.discoveryTimer) {
+            this.discoveryTimer = setInterval(() => {
+                try {
+                    this.discover();
+                }
+                catch (err) {
+                    this.emitter.emit('error', err instanceof Error ? err : new Error(String(err)));
+                }
+            }, this.discoveryIntervalMs);
+        }
     }
     /** Stop and cleanup */
     stop() {
@@ -138,19 +139,25 @@ export class LxClient {
     }
     /** Handle incoming message */
     handleMessage(data, fromIp, fromPort) {
+        this.log(`[LxClient] handleMessage: ${data.length} bytes from ${fromIp}:${fromPort}`);
         let msg;
         try {
             msg = decodeMessage(data);
+            const typeName = MessageTypeName(msg.type);
+            this.log(`[LxClient] decoded message type=${msg.type} (${typeName}), target=${msg.target}`);
         }
         catch (e) {
             this.emit('error', new Error(`Decode error: ${e.message}`));
             return;
         }
         const mac = msg.target;
-        if (mac === '00:00:00:00:00:00')
-            return; /** broadcast response without target */
+        if (mac === '00:00:00:00:00:00') {
+            this.log(`[LxClient] ignoring broadcast response (no target)`);
+            return;
+        }
         let device = this.devices.get(mac);
         const isNew = !device;
+        this.log(`[LxClient] mac=${mac}, isNew=${isNew}, deviceCount=${this.devices.size}`);
         if (!device) {
             device = new LxDevice(mac, fromIp);
             device.setTransport(this.transport);
@@ -161,12 +168,16 @@ export class LxClient {
         device.port = fromPort;
         device.markSeen();
         // Check for duplicate message (some LIFX devices send responses twice)
-        if (device.isDuplicate(msg.sequence)) {
-            return; // Ignore duplicate
+        // Use both sequence AND type - different types with same seq are valid (e.g., Ack + State)
+        if (device.isDuplicate(msg.sequence, msg.type)) {
+            this.log(`[LxClient] ignoring duplicate seq=${msg.sequence} type=${msg.type}`);
+            return;
         }
         if (isNew) {
             this.emit('device', device);
         }
+        const typeName = MessageTypeName(msg.type);
+        this.log(`[LxClient] processing msg.type=#${msg.type} ${typeName} (State=${MessageType.State})`);
         this.emit('message', device, msg);
         switch (msg.type) {
             case MessageType.StateService: {
@@ -176,7 +187,12 @@ export class LxClient {
                 break;
             }
             case MessageType.State: {
+                // Hex dump first 20 bytes to debug power offset
+                const hex = Array.from(msg.payload.slice(0, 20)).map(b => b.toString(16).padStart(2, '0')).join(' ');
+                this.log(`[LxClient] State payload[0:20]: ${hex}`, 'navy,white');
                 const state = decodeState(msg.payload);
+                this.log(`[LxClient] raw state.power=${state.power} (0=off, 65535=on) at offset 10`);
+                this.log(`[LxClient] raw state.hsbk=${JSON.stringify(state)} at offset 12`);
                 device.color = hsbk16ToHsbk(state.hsbk);
                 device.power = state.power > 0;
                 device.label = state.label;
@@ -184,11 +200,14 @@ export class LxClient {
                 // State messages also respond to SetPower and SetColor
                 device.markResponseReceived(MessageType.SetPower);
                 device.markResponseReceived(MessageType.SetColor);
-                this.emit('state', device);
+                // primary = true if from device, false if from peer client broadcast
+                const primary = fromIp === device.ip;
+                this.log(`[LxClient] emitting 'state' for ${device.mac}, power=${device.power}, primary=${primary}`);
+                this.emit('state', device, { primary });
                 // Multi-client state synchronization: broadcast to other clients
                 // Safe fail approach: only rebroadcast if from device IP
                 // If not from device.ip, assume it's a client broadcast - just update local state, don't rebroadcast
-                if (this.clientBroadcastEnabled && fromIp === device.ip) {
+                if (this.clientBroadcastEnabled && primary) {
                     this.broadcastState(data);
                 }
                 break;

package/device.d.ts

@@ -44,8 +44,8 @@ export declare class LxDevice {
     group: GroupInfo;
     /** Location membership */
     location: GroupInfo;
-    /** Recent message sequences for deduplication (sequence -> timestamp) */
-    private recentSequences;
+    /** Recent messages for deduplication (sequence:type -> timestamp) */
+    private recentMessages;
     private transport?;
     /** Pending requests awaiting responses (message type -> timeout) */
     private pendingRequests;
@@ -80,11 +80,24 @@ export declare class LxDevice {
     /** Set power on/off */
     setPower(on: boolean): void;
     /**
-     * Set brightness while keeping current color
+     * Set brightness without affecting hue, saturation, or kelvin.
+     * Uses SetWaveformOptional (type 119) — device keeps its current color temperature.
      * @param brightness - Brightness 0-100
      * @param duration - Transition time in milliseconds (default 0)
      */
     setBrightness(brightness: number, duration?: number): void;
+    /**
+     * Set individual HSBK values without affecting unspecified fields.
+     * Uses SetWaveformOptional (type 119) — only fields present in the object are applied.
+     * @param values - Partial HSBK: { h?, s?, b?, k? } (h=0-360, s=0-100, b=0-100, k=1500-9000)
+     * @param duration - Transition time in milliseconds (default 0)
+     */
+    setValues(values: {
+        h?: number;
+        s?: number;
+        b?: number;
+        k?: number;
+    }, duration?: number): void;
     /**
      * Set color - accepts flexible input formats
      * @param color - Color as hex "#ff0000", RGB {r,g,b}, HSL {h,s,l}, HSB {h,s,b}, HSBK {h,s,b,k}, or Kelvin number
@@ -135,11 +148,13 @@ export declare class LxDevice {
     /** Notify that a response was received for a message type */
     markResponseReceived(messageType: number): void;
     /**
-     * Check if message is a duplicate based on sequence number.
+     * Check if message is a duplicate based on sequence number AND type.
      * LIFX devices sometimes send duplicate responses.
+     * Different message types with same sequence are NOT duplicates (e.g., Ack + State).
      * @param sequence - Message sequence number
+     * @param type - Message type number
      * @returns true if duplicate (already seen recently)
      */
-    isDuplicate(sequence: number): boolean;
+    isDuplicate(sequence: number, type: number): boolean;
 }
 //# sourceMappingURL=device.d.ts.map

package/device.js

@@ -1,6 +1,6 @@
 import { parseColor, hsbkTo16 } from '@bobfrankston/colorlib';
 import { MessageType, Products, LIFX_PORT } from './types.js';
-import { encodeMessage, encodeSetPower, encodeSetColor, encodeSetLabel, encodeSetGroup, encodeSetLocation } from './protocol.js';
+import { encodeMessage, encodeSetPower, encodeSetColor, encodeSetWaveformOptional, encodeSetLabel, encodeSetGroup, encodeSetLocation } from './protocol.js';
 /**
  * Represents a LIFX device on the LAN.
  * State is cached and updated via events from LxClient.
@@ -44,8 +44,8 @@ export class LxDevice {
     group = { id: '', label: '', updatedAt: 0 };
     /** Location membership */
     location = { id: '', label: '', updatedAt: 0 };
-    /** Recent message sequences for deduplication (sequence -> timestamp) */
-    recentSequences = new Map();
+    /** Recent messages for deduplication (sequence:type -> timestamp) */
+    recentMessages = new Map();
     transport;
     /** Pending requests awaiting responses (message type -> timeout) */
     pendingRequests = new Map();
@@ -121,6 +121,7 @@ export class LxDevice {
     /** Set power on/off */
     setPower(on) {
         this.requireTransport();
+        this.power = on;
         const msg = encodeMessage({
             type: MessageType.SetPower,
             target: this.mac,
@@ -133,15 +134,42 @@ export class LxDevice {
         this.startRequestTimeout(MessageType.SetPower);
     }
     /**
-     * Set brightness while keeping current color
+     * Set brightness without affecting hue, saturation, or kelvin.
+     * Uses SetWaveformOptional (type 119) — device keeps its current color temperature.
      * @param brightness - Brightness 0-100
      * @param duration - Transition time in milliseconds (default 0)
      */
     setBrightness(brightness, duration = 0) {
+        this.setValues({ b: brightness }, duration);
+    }
+    /**
+     * Set individual HSBK values without affecting unspecified fields.
+     * Uses SetWaveformOptional (type 119) — only fields present in the object are applied.
+     * @param values - Partial HSBK: { h?, s?, b?, k? } (h=0-360, s=0-100, b=0-100, k=1500-9000)
+     * @param duration - Transition time in milliseconds (default 0)
+     */
+    setValues(values, duration = 0) {
         this.requireTransport();
-        // Keep current hue/saturation/kelvin, just change brightness
-        const newColor = { ...this.color, b: brightness };
-        this.setColor(newColor, duration);
+        const hsbk16 = hsbkTo16({
+            h: values.h ?? 0,
+            s: values.s ?? 0,
+            b: values.b ?? 0,
+            k: values.k ?? 3500
+        });
+        const msg = encodeMessage({
+            type: MessageType.SetWaveformOptional,
+            target: this.mac,
+            payload: encodeSetWaveformOptional(hsbk16, duration, {
+                setHue: values.h !== undefined,
+                setSaturation: values.s !== undefined,
+                setBrightness: values.b !== undefined,
+                setKelvin: values.k !== undefined
+            }),
+            ackRequired: true,
+            resRequired: true
+        });
+        this.transport.send(this.ip, this.port, msg);
+        this.startRequestTimeout(MessageType.SetWaveformOptional);
     }
     /**
      * Set color - accepts flexible input formats
@@ -267,25 +295,28 @@ export class LxDevice {
         this.clearRequestTimeout(messageType);
     }
     /**
-     * Check if message is a duplicate based on sequence number.
+     * Check if message is a duplicate based on sequence number AND type.
      * LIFX devices sometimes send duplicate responses.
+     * Different message types with same sequence are NOT duplicates (e.g., Ack + State).
      * @param sequence - Message sequence number
+     * @param type - Message type number
      * @returns true if duplicate (already seen recently)
      */
-    isDuplicate(sequence) {
+    isDuplicate(sequence, type) {
         const now = Date.now();
         const DUPLICATE_WINDOW_MS = 2000; // 2 second window
+        const key = `${sequence}:${type}`;
         // Clean old entries
-        for (const [seq, timestamp] of this.recentSequences.entries()) {
+        for (const [k, timestamp] of this.recentMessages.entries()) {
             if (now - timestamp > DUPLICATE_WINDOW_MS) {
-                this.recentSequences.delete(seq);
+                this.recentMessages.delete(k);
             }
         }
-        // Check if we've seen this sequence recently
-        if (this.recentSequences.has(sequence)) {
+        // Check if we've seen this exact sequence+type recently
+        if (this.recentMessages.has(key)) {
             return true;
         }
-        this.recentSequences.set(sequence, now);
+        this.recentMessages.set(key, now);
         return false;
     }
 }

package/index.d.ts

@@ -3,5 +3,5 @@ export { LxDevice } from './device.js';
 export { LxClient, LxClientOptions } from './client.js';
 export { UdpTransport, LxTransport, RemoteInfo } from './transport.js';
 export { LxEventEmitter, LxEventEmitterBase } from './events.js';
-export { encodeMessage, decodeMessage } from './protocol.js';
+export { encodeMessage, decodeMessage, encodeSetWifiConfiguration, encodeGetWifiConfiguration, decodeStateWifiConfiguration, encodeSetLabel, encodeSetColor, encodeSetPower, encodeSetGroup, encodeSetLocation, encodeSetWaveformOptional, encodeGetService, decodeState, decodeStatePower, decodeStateLabel, decodeStateVersion, decodeStateGroup, decodeStateService, decodeStateHostInfo, decodeStateHostFirmware, decodeStateWifiInfo, decodeStateInfo, FrameFlags, ProtocolBits, nextSequence, getSource, } from './protocol.js';
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -2,5 +2,5 @@ export * from './types.js';
 export { LxDevice } from './device.js';
 export { LxClient } from './client.js';
 export { LxEventEmitterBase } from './events.js';
-export { encodeMessage, decodeMessage } from './protocol.js';
+export { encodeMessage, decodeMessage, encodeSetWifiConfiguration, encodeGetWifiConfiguration, decodeStateWifiConfiguration, encodeSetLabel, encodeSetColor, encodeSetPower, encodeSetGroup, encodeSetLocation, encodeSetWaveformOptional, encodeGetService, decodeState, decodeStatePower, decodeStateLabel, decodeStateVersion, decodeStateGroup, decodeStateService, decodeStateHostInfo, decodeStateHostFirmware, decodeStateWifiInfo, decodeStateInfo, FrameFlags, ProtocolBits, nextSequence, getSource, } from './protocol.js';
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/lxlan",
-  "version": "0.1.13",
+  "version": "0.1.16",
   "description": "LIFX LAN protocol library for device control via UDP",
   "type": "module",
   "main": "index.js",
@@ -31,11 +31,14 @@
     "url": "https://github.com/BobFrankston/lxlan.git"
   },
   "dependencies": {
-    "@bobfrankston/colorlib": "^0.1.7",
+    "@bobfrankston/colorlib": "^0.1.8",
     "@bobfrankston/udp-transport": "^1.0.2"
   },
   "devDependencies": {
-    "@types/node": "^25.0.9"
+    "@types/node": "^25.2.1"
+  },
+  "publishConfig": {
+    "access": "public"
   },
   ".dependencies": {
     "@bobfrankston/colorlib": "file:../../../../utils/colorlib",

package/protocol.d.ts

@@ -1,5 +1,5 @@
 import { HSBK16 } from '@bobfrankston/colorlib';
-import { LxMessage } from './types.js';
+import { LxMessage, WifiConfigState } from './types.js';
 /** LIFX protocol frame flags */
 export declare const FrameFlags: {
     readonly ResRequired: 1;
@@ -31,6 +31,16 @@ export declare function decodeMessage(buf: Uint8Array): LxMessage;
 export declare function encodeSetPower(level: boolean): Uint8Array;
 /** Encode SetColor payload */
 export declare function encodeSetColor(hsbk: HSBK16, duration?: number): Uint8Array;
+/** Encode SetWaveformOptional payload (type 119)
+ * Allows setting individual HSBK fields without affecting others.
+ * Set the corresponding set_* flag to true to apply that field.
+ */
+export declare function encodeSetWaveformOptional(hsbk: HSBK16, duration?: number, flags?: {
+    setHue?: boolean;
+    setSaturation?: boolean;
+    setBrightness?: boolean;
+    setKelvin?: boolean;
+}): Uint8Array;
 /** Encode SetLabel payload */
 export declare function encodeSetLabel(label: string): Uint8Array;
 /** Encode SetGroup payload */
@@ -89,4 +99,10 @@ export declare function decodeStateInfo(payload: Uint8Array): {
 };
 /** Encode GetService payload (empty) */
 export declare function encodeGetService(): Uint8Array;
+/** Encode SetWifiConfiguration (Type 301) payload — 98 bytes */
+export declare function encodeSetWifiConfiguration(ssid: string, pass: string, security?: number): Uint8Array;
+/** Encode GetWifiConfiguration (Type 302) — no payload */
+export declare function encodeGetWifiConfiguration(): Uint8Array;
+/** Decode StateWifiConfiguration (Type 303) payload */
+export declare function decodeStateWifiConfiguration(payload: Uint8Array): WifiConfigState;
 //# sourceMappingURL=protocol.d.ts.map

package/protocol.js

@@ -1,4 +1,4 @@
-import { HEADER_SIZE } from './types.js';
+import { HEADER_SIZE, WifiSecurity, WifiInterface } from './types.js';
 /** LIFX protocol frame flags */
 export const FrameFlags = {
     ResRequired: 0x01, /** Response required from device */
@@ -154,6 +154,30 @@ export function encodeSetColor(hsbk, duration = 0) {
     writeUInt32LE(buf, duration, 9);
     return buf;
 }
+/** Encode SetWaveformOptional payload (type 119)
+ * Allows setting individual HSBK fields without affecting others.
+ * Set the corresponding set_* flag to true to apply that field.
+ */
+export function encodeSetWaveformOptional(hsbk, duration = 0, flags = {}) {
+    const buf = new Uint8Array(25);
+    buf[0] = 0; // reserved
+    buf[1] = 0; // transient = false (permanent)
+    writeUInt16LE(buf, hsbk.h, 2); // hue
+    writeUInt16LE(buf, hsbk.s, 4); // saturation
+    writeUInt16LE(buf, hsbk.b, 6); // brightness
+    writeUInt16LE(buf, hsbk.k, 8); // kelvin
+    writeUInt32LE(buf, duration, 10); // period (ms) — used as transition duration
+    // cycles (float32) at offset 14 — 1.0 for single transition
+    const view = new DataView(buf.buffer, buf.byteOffset + 14, 4);
+    view.setFloat32(0, 1.0, true);
+    writeUInt16LE(buf, 0, 18); // skew_ratio = 0
+    buf[20] = 0; // waveform = SAW
+    buf[21] = flags.setHue ? 1 : 0; // set_hue
+    buf[22] = flags.setSaturation ? 1 : 0; // set_saturation
+    buf[23] = flags.setBrightness ? 1 : 0; // set_brightness
+    buf[24] = flags.setKelvin ? 1 : 0; // set_kelvin
+    return buf;
+}
 /** Encode SetLabel payload */
 export function encodeSetLabel(label) {
     const buf = new Uint8Array(32);
@@ -256,6 +280,27 @@ export function decodeStateInfo(payload) {
 export function encodeGetService() {
     return new Uint8Array(0);
 }
+/** Encode SetWifiConfiguration (Type 301) payload — 98 bytes */
+export function encodeSetWifiConfiguration(ssid, pass, security = WifiSecurity.WPA2) {
+    const buf = new Uint8Array(98);
+    buf[0] = WifiInterface.Station;
+    utf8Encode(ssid, buf, 1, 32);
+    utf8Encode(pass, buf, 33, 64);
+    buf[97] = security;
+    return buf;
+}
+/** Encode GetWifiConfiguration (Type 302) — no payload */
+export function encodeGetWifiConfiguration() {
+    return new Uint8Array(0);
+}
+/** Decode StateWifiConfiguration (Type 303) payload */
+export function decodeStateWifiConfiguration(payload) {
+    return {
+        iface: payload[0],
+        ssid: utf8Decode(payload, 1, 33),
+        security: payload[97],
+    };
+}
 // Buffer compatibility helper
 const BufferImpl = typeof Buffer !== 'undefined' ? Buffer : class {
     static alloc(size) {

package/types.d.ts

@@ -26,6 +26,7 @@ export declare const MessageType: {
     readonly StateVersion: 33;
     readonly GetInfo: 34;
     readonly StateInfo: 35;
+    readonly Acknowledge: 45;
     readonly GetLocation: 48;
     readonly SetLocation: 49;
     readonly StateLocation: 50;
@@ -34,8 +35,30 @@ export declare const MessageType: {
     readonly StateGroup: 53;
     readonly Get: 101;
     readonly SetColor: 102;
+    readonly SetWaveformOptional: 119;
     readonly State: 107;
+    readonly SetWifiConfiguration: 301;
+    readonly GetWifiConfiguration: 302;
+    readonly StateWifiConfiguration: 303;
 };
+/** Wi-Fi security modes for onboarding */
+export declare const WifiSecurity: {
+    readonly Open: 1;
+    readonly WEP: 2;
+    readonly WPA: 3;
+    readonly WPA2: 4;
+};
+/** Wi-Fi interface type */
+export declare const WifiInterface: {
+    readonly Station: 6;
+};
+/** Wi-Fi configuration state (from Type 303 response) */
+export interface WifiConfigState {
+    iface: number; /** Interface type (6 = Station) */
+    ssid: string;
+    security: number;
+}
+export declare function MessageTypeName(type: number): string;
 export type MessageTypeValue = typeof MessageType[keyof typeof MessageType];
 /** LIFX message structure */
 export interface LxMessage {
@@ -85,6 +108,11 @@ export interface DeviceState {
     uptime?: number;
     downtime?: number;
 }
+/** Info passed with state events */
+export interface StateEventInfo {
+    /** true if from device response, false if from peer client broadcast */
+    primary: boolean;
+}
 /** LIFX port */
 export declare const LIFX_PORT = 56700;
 /** Header size */

package/types.js

@@ -18,6 +18,7 @@ export const MessageType = {
     StateVersion: 33,
     GetInfo: 34,
     StateInfo: 35,
+    Acknowledge: 45,
     GetLocation: 48,
     SetLocation: 49,
     StateLocation: 50,
@@ -26,8 +27,31 @@ export const MessageType = {
     StateGroup: 53,
     Get: 101, /** GetColor */
     SetColor: 102,
+    SetWaveformOptional: 119, /** Set HSBK with per-field control flags */
     State: 107, /** LightState */
+    SetWifiConfiguration: 301, /** Onboarding: set Wi-Fi credentials */
+    GetWifiConfiguration: 302, /** Onboarding: query current Wi-Fi config */
+    StateWifiConfiguration: 303, /** Onboarding: response with current Wi-Fi config */
 };
+/** Wi-Fi security modes for onboarding */
+export const WifiSecurity = {
+    Open: 1,
+    WEP: 2,
+    WPA: 3,
+    WPA2: 4,
+};
+/** Wi-Fi interface type */
+export const WifiInterface = {
+    Station: 6, /** Station mode (join existing network) */
+};
+// This is for debuging so it doesn't have to be that
+export function MessageTypeName(type) {
+    for (const [name, val] of Object.entries(MessageType)) {
+        if (val === type)
+            return name;
+    }
+    return `Unknown(${type})`;
+}
 /** LIFX port */
 export const LIFX_PORT = 56700;
 /** Header size */