@openmouse/protocol 0.1.0

package/dist/razer/codec.d.ts

@@ -0,0 +1,504 @@
+/**
+ * Razer control protocol: 90-byte feature reports exchanged on report ID 0.
+ *
+ * Razer does not declare this report in its HID descriptor, so the collection
+ * carries no feature report of its own; the exchange still succeeds because
+ * WebHID does not validate report IDs against the descriptor. The control
+ * interface is the one whose only collection is Generic Desktop Mouse.
+ */
+export declare const RAZER_REPORT_ID = 0;
+export declare const RAZER_PACKET_LENGTH = 90;
+/**
+ * Razer's three transaction ids.
+ *
+ * Named by value on purpose. They carry no meaning beyond "which firmware
+ * generation answers to this", they do not order neatly by device age, and
+ * every name that tried to describe them has been wrong: `_LEGACY` for `0x3f`
+ * read as "the oldest one" when `0xff` is older, and `_DEFAULT` for `0xff`
+ * read as "use this when unsure" when there is no safe default at all. A
+ * mismatch is silent — the mouse simply never replies — so every product must
+ * state its own id and none may be inferred from a family name.
+ *
+ * The same three values are what OpenRazer's driver selects between, and what
+ * the reference notes type as `"ff" | "3f" | "1f"`.
+ */
+export declare const RAZER_TRANSACTION_ID_FF = 255;
+export declare const RAZER_TRANSACTION_ID_3F = 63;
+export declare const RAZER_TRANSACTION_ID_1F = 31;
+/**
+ * Default for `encodeRazerRequest`. Verified against Viper V3 Pro firmware 1.12
+ * on both transports; the per-product table overrides it for everything else.
+ */
+export declare const RAZER_TRANSACTION_ID = 31;
+/**
+ * The button-mapping write (class `0x02`) is the one command on this mouse
+ * that rejects `RAZER_TRANSACTION_ID` silently: status `0x02` (ok), the
+ * read-back even changes, but the physical button keeps its old function.
+ * Confirmed on hardware by writing a plain mouse-button action, pressing the
+ * button, and finding it unchanged with `0x1f` and correct with any other id
+ * (`0x02` and `0x10` both round-tripped and worked physically). Every other
+ * write on this mouse uses `0x1f` without issue, so this is specific to class
+ * `0x02` rather than a general transport quirk.
+ */
+export declare const RAZER_BUTTON_TRANSACTION_ID = 16;
+export declare const RAZER_STATUS: {
+    readonly busy: 1;
+    readonly ok: 2;
+    readonly failure: 3;
+    readonly timeout: 4;
+    readonly unsupported: 5;
+};
+export interface RazerCommand {
+    commandClass: number;
+    commandId: number;
+    dataSize: number;
+    args?: readonly number[];
+    /** Overrides the per-product transaction id for this command alone. See `RAZER_BUTTON_TRANSACTION_ID`. */
+    transactionId?: number;
+}
+/**
+ * Razer selects a value store per command. Firmware 1.12 reports the same DPI
+ * from either store, and writes were confirmed against this one, so reads and
+ * writes both use it rather than risking a stale read from the other. The V2
+ * generation (DeathAdder V2 and its siblings) reads and writes through
+ * NOSTORE (`0x00`) instead, which OpenRazer's driver selects per device.
+ */
+export declare const RAZER_STORAGE = 1;
+/** Read-only commands confirmed against Viper V3 Pro firmware 1.12. */
+export declare const RAZER_READ: {
+    readonly firmware: {
+        readonly commandClass: 0;
+        readonly commandId: 129;
+        readonly dataSize: 2;
+    };
+    readonly serial: {
+        readonly commandClass: 0;
+        readonly commandId: 130;
+        readonly dataSize: 22;
+    };
+    readonly battery: {
+        readonly commandClass: 7;
+        readonly commandId: 128;
+        readonly dataSize: 2;
+    };
+    readonly charging: {
+        readonly commandClass: 7;
+        readonly commandId: 132;
+        readonly dataSize: 2;
+    };
+    readonly sleepTimeout: {
+        readonly commandClass: 7;
+        readonly commandId: 131;
+        readonly dataSize: 2;
+    };
+    readonly lowPowerThreshold: {
+        readonly commandClass: 7;
+        readonly commandId: 129;
+        readonly dataSize: 2;
+    };
+    readonly dpi: {
+        readonly commandClass: 4;
+        readonly commandId: 133;
+        readonly dataSize: 7;
+        readonly args: readonly [1];
+    };
+    readonly dpiStages: {
+        readonly commandClass: 4;
+        readonly commandId: 134;
+        readonly dataSize: 38;
+        readonly args: readonly [0];
+    };
+    readonly pollingRate: {
+        readonly commandClass: 0;
+        readonly commandId: 133;
+        readonly dataSize: 1;
+    };
+    readonly pollingRateExtended: {
+        readonly commandClass: 0;
+        readonly commandId: 192;
+        readonly dataSize: 2;
+        readonly args: readonly [0];
+    };
+    readonly liftOff: {
+        readonly commandClass: 11;
+        readonly commandId: 133;
+        readonly dataSize: 5;
+    };
+    /**
+     * One control's button mapping. `args` is `[0x01, controlIndex, layer]`.
+     * `controlIndex` reliably selects the right control — confirmed by reading
+     * several controls back to back and always getting that control's own data.
+     * `layer` is not honored the same way: requesting Hypershift (`0x01`) for a
+     * control whose Standard mapping was just read back returned the Standard
+     * value again. Only Standard-layer reads are trusted.
+     */
+    readonly buttonMapping: {
+        readonly commandClass: 2;
+        readonly commandId: 140;
+        readonly dataSize: 10;
+    };
+};
+/**
+ * Write commands confirmed against Viper V3 Pro firmware 1.12.
+ *
+ * Razer pairs each read with a write that clears the high bit of the command
+ * id. Only commands verified on hardware belong here — in particular the DPI
+ * stage table (`0x04`/`0x06`) is absent on purpose, because a wrong length
+ * there is the one realistic way to corrupt stored settings.
+ */
+export declare const RAZER_WRITE: {
+    readonly dpi: {
+        readonly commandClass: 4;
+        readonly commandId: 5;
+        readonly dataSize: 7;
+    };
+    readonly pollingRate: {
+        readonly commandClass: 0;
+        readonly commandId: 5;
+        readonly dataSize: 1;
+    };
+    readonly pollingRateExtended: {
+        readonly commandClass: 0;
+        readonly commandId: 64;
+        readonly dataSize: 2;
+    };
+    readonly liftOff: {
+        readonly commandClass: 11;
+        readonly commandId: 5;
+        readonly dataSize: 10;
+    };
+    readonly sensorSetting: {
+        readonly commandClass: 11;
+        readonly commandId: 11;
+        readonly dataSize: 4;
+    };
+    readonly sleepTimeout: {
+        readonly commandClass: 7;
+        readonly commandId: 3;
+        readonly dataSize: 2;
+    };
+    readonly lowPowerThreshold: {
+        readonly commandClass: 7;
+        readonly commandId: 1;
+        readonly dataSize: 2;
+    };
+    /**
+     * Silently rejects `RAZER_TRANSACTION_ID` — see `RAZER_BUTTON_TRANSACTION_ID`.
+     * `razerSetButtonMappingCommand` and `razerSetToggleControlCommand` are the
+     * only places that should build this.
+     *
+     * **Stored in device memory, not volatile.** Confirmed on a Viper V3 Pro
+     * (`0x00c1`): Mouse Button 4 was disabled, the host application closed, the
+     * mouse powered off at its switch for 10 seconds and powered back on. The
+     * button was still dead on reconnect and the read reported Disabled, with
+     * Synapse never running. So a caller does not need to re-apply mappings
+     * after a power cycle, and a user's change survives independently of any
+     * host software.
+     *
+     * The leading argument byte is always `0x01` here. On this device `0x01` is
+     * also `RAZER_STORAGE`, the persistent store DPI writes through, which makes
+     * a storage selector the obvious reading — but that byte has never been
+     * varied on this command, so it is recorded as an unknown rather than
+     * assigned that meaning.
+     */
+    readonly buttonMapping: {
+        readonly commandClass: 2;
+        readonly commandId: 12;
+        readonly dataSize: 10;
+        readonly transactionId: 16;
+    };
+};
+export declare function razerSetDpiCommand(x: number, y: number, storageByte?: number): RazerCommand;
+/**
+ * The DPI read, parameterized by the store byte. The V3 family reads the
+ * storage byte (`0x01`), but the V2 generation reads the no-store byte (`0x00`)
+ * — OpenRazer's driver calls `get_dpi_xy(NOSTORE)` for them — so the shared
+ * `RAZER_READ.dpi` cannot be used verbatim.
+ */
+export declare function razerReadDpiCommand(storageByte?: number): RazerCommand;
+/** Seconds, big-endian, in the same encoding the matching read returns. */
+export declare function razerSetSleepTimeoutCommand(seconds: number): RazerCommand;
+/**
+ * The payload mirrors the matching read byte for byte: the level on the 0–255
+ * scale first, then a trailing zero. Confirmed on hardware by writing 85% and
+ * finding `d9 00` still held after a reload.
+ */
+export declare function razerSetLowPowerThresholdCommand(percent: number): RazerCommand;
+export declare function razerSetLegacyPollingCommand(pollingRateHz: number): RazerCommand;
+/** The receiver takes the same leading argument its read echoes back. */
+export declare function razerSetExtendedPollingCommand(pollingRateHz: number): RazerCommand;
+export type RazerExtendedEffect = "off" | "static" | "spectrum" | "reactive" | "breathing-random" | "breathing-single" | "breathing-dual";
+/** Effect ids from openrazer's `razer_chroma_extended_matrix_effect_*` family. */
+export declare const RAZER_EFFECT: {
+    readonly off: 0;
+    readonly static: 1;
+    readonly spectrum: 3;
+    readonly reactive: 5;
+    readonly "breathing-random": 2;
+    readonly "breathing-single": 2;
+    readonly "breathing-dual": 2;
+};
+export type RazerReactiveSpeed = 1 | 2 | 3 | 4;
+/** Synapse's reactive speed scale: 1 is fast, 4 is slow. */
+export declare const RAZER_EFFECT_SPEED: {
+    readonly 1: 1;
+    readonly 2: 2;
+    readonly 3: 3;
+    readonly 4: 4;
+};
+export declare function parseRazerColor(hex: string): [number, number, number];
+/**
+ * Extended effect command for the Viper Mini's extended-matrix family (`0x0f` /
+ * `0x02`), matching openrazer's `razer_chroma_extended_matrix_effect_*`
+ * functions, which this mouse dispatches through with `VARSTORE` and the logo
+ * led. The mouse's one 1x1 matrix means a single underglow zone.
+ *
+ * All effects share the `[VARSTORE, logo, effect]` header. Breathing variants
+ * differ only in the colour count byte and payload length, and reactive adds a
+ * speed level between the header and its single colour.
+ */
+export declare function razerSetExtendedEffectCommand(effect: RazerExtendedEffect, options?: {
+    color?: string;
+    color2?: string;
+    speed?: RazerReactiveSpeed;
+}): RazerCommand;
+export declare class RazerProtocolError extends Error {
+    readonly status: number | null;
+    /**
+     * The reply belonged to an earlier exchange, so re-reading may still find the
+     * right one. Distinct from a failure status, which the mouse meant for us.
+     */
+    readonly stale: boolean;
+    constructor(message: string, status?: number | null, stale?: boolean);
+}
+/**
+ * Razer pairs each read with a write that clears the high bit of the command
+ * id, so the bit is what separates a question from an instruction. Repeating a
+ * question costs nothing; repeating an instruction is what the reference means
+ * by "do not automatically retry writes".
+ */
+export declare function isRazerGetter(command: RazerCommand): boolean;
+export declare function razerChecksum(packet: Uint8Array): number;
+export declare function encodeRazerRequest(command: RazerCommand, transactionId?: number): Uint8Array<ArrayBuffer>;
+/** Returns the reply arguments, or throws with the reported status. */
+export declare function decodeRazerResponse(packet: Uint8Array, command: RazerCommand): Uint8Array;
+export declare function decodeFirmwareVersion(args: Uint8Array): string;
+export declare function decodeSerial(args: Uint8Array): string;
+export declare function decodeBatteryPercent(args: Uint8Array): number;
+/**
+ * The low-power threshold shares the battery level's 0–255 scale rather than
+ * being a percentage, so 0x4d is 30% and reading it as a percent is wrong by a
+ * factor of two and a half.
+ *
+ * It also sits in the *first* argument byte, where battery, charging and sleep
+ * all pad with a leading zero and answer in the second. The mouse replied
+ * `4d 00` where Synapse showed 30%, so the class is not consistent about this
+ * and the shared decoder cannot be reused.
+ */
+export declare function decodeLowPowerThreshold(args: Uint8Array): number;
+export declare function encodeBatteryLevel(percent: number): number;
+export declare function decodeCharging(args: Uint8Array): boolean;
+/**
+ * Idle sleep is a whole number of seconds, unlike battery and charging in the
+ * same class, which pad their one meaningful byte with a leading zero.
+ */
+export declare function decodeSleepTimeout(args: Uint8Array): number;
+export interface RazerDpi {
+    x: number;
+    y: number;
+}
+export declare function decodeDpi(args: Uint8Array): RazerDpi;
+export interface RazerDpiStages {
+    /** One-based index into `stages`, as reported by the mouse. */
+    active: number;
+    stages: RazerDpi[];
+}
+export declare function decodeDpiStages(args: Uint8Array): RazerDpiStages;
+/**
+ * Lift-off distance. The vendor software presents this as two different
+ * controls behind one checkbox, and the mouse stores both independently:
+ *
+ * - Asymmetric off: a single three-stop slider, "Tracking Distance".
+ * - Asymmetric on: two 26-step sliders, lift-off and landing.
+ *
+ * Switching modes leaves the other mode's stored value untouched, so neither
+ * reading destroys the other.
+ */
+export type RazerTrackingDistance = "Low" | "Medium" | "High";
+/** Indexed by the byte the mouse reports, so the order is the encoding. */
+export declare const RAZER_TRACKING_DISTANCES: readonly RazerTrackingDistance[];
+/** Synapse's own numbering. Landing must stay strictly below lift-off. */
+export declare const RAZER_LIFT_OFF_MIN = 2;
+export declare const RAZER_LIFT_OFF_MAX = 26;
+export declare const RAZER_LANDING_MIN = 1;
+export declare const RAZER_LANDING_MAX = 25;
+export interface RazerLiftOff {
+    /** Null when the mouse reports a level outside the three the slider offers. */
+    tracking: RazerTrackingDistance | null;
+    liftOff: number;
+    landing: number;
+}
+/**
+ * Both asymmetric levels are stored one below the number Synapse displays, so
+ * lift-off 26 is 0x19 and landing 25 is 0x18. Confirmed at 5/4, 16/11 and 26/25,
+ * with the middle reading predicted before it was measured.
+ *
+ * Byte[0] echoes whatever argument the request carried and byte[1] was zero in
+ * every capture, so neither is read here — arguments 0x00 through 0x07 all
+ * returned the same levels, which rules out a per-profile store.
+ */
+export declare function decodeLiftOff(args: Uint8Array): RazerLiftOff;
+/**
+ * The highest landing a given lift-off permits: lift-off 10 allows 9, and so on
+ * down to the floor of 1.
+ *
+ * Landing is bounded by lift-off rather than locked to it — the vendor software
+ * caps its own slider the same way, and 16/11 is a perfectly ordinary pair. The
+ * firmware stores an inverted pair without complaint, and one session left the
+ * mouse holding lift-off 2 with landing 26, which the vendor software cannot
+ * even express. Nothing downstream catches that, so the rule is enforced here.
+ */
+export declare function razerMaxLanding(liftOff: number): number;
+/**
+ * Selects the mouse's symmetric tracking distance, and by doing so switches it
+ * out of asymmetric mode.
+ *
+ * The mouse has no readable mode bit and no mode flag to set. It honours
+ * whichever of the two stores was written most recently, so writing a tracking
+ * level *is* the way to return to symmetric — confirmed by the asymmetric pair
+ * write being rejected immediately afterwards.
+ */
+export declare function razerSetTrackingDistanceCommand(distance: RazerTrackingDistance): RazerCommand;
+/**
+ * Unlocks the asymmetric pair write, which the mouse rejects with status `0x03`
+ * in symmetric mode — and rejects while still moving what the read reports, so
+ * skipping this produces a driver that appears to work and never touches the
+ * sensor.
+ *
+ * There is no matching disable. Sending value `0x00` was accepted and changed
+ * nothing; the vendor software leaves asymmetric mode by writing a tracking
+ * level instead, which is what `razerSetTrackingDistanceCommand` does.
+ */
+export declare function razerEnableAsymmetricLiftOffCommand(): RazerCommand;
+/**
+ * Canonical asymmetric lift-off unlock: the same sensor-setting write as
+ * `razerEnableAsymmetricLiftOffCommand` with value `0x00`. The 1.14 sweep found
+ * both values arm the pair write, but only the `0x01` form is verified on
+ * 1.12, so this is the driver's fallback arm, never the shipped form.
+ */
+export declare function razerEnableAsymmetricLiftOffCanonicalCommand(): RazerCommand;
+/**
+ * Calibration-mode-on step, `0x0b`/`0x03` `00 04 01`. Not required on the
+ * swept firmware 1.14 units, where the unlock alone arms the pair write, so it
+ * is sent only as the last-resort arm in `setLiftOff` for a unit that refuses
+ * both unlock values. Carries the same sensor selector as the settings writes;
+ * the layout is read off the experiment notes rather than verified on
+ * hardware, which is why it comes last.
+ */
+export declare function razerEnableSensorCalibrationCommand(): RazerCommand;
+/**
+ * Lift-off write, transcribed from the vendor software's own packet rather than
+ * inferred: `dataSize 0x0a`, then `00 04` before the pair. It does NOT mirror
+ * the read's layout, which is what three earlier guesses assumed — each was
+ * answered `0x03` while still disturbing the stored values.
+ *
+ * Must be preceded by `razerEnableAsymmetricLiftOffCommand`.
+ *
+ * Confirmed on hardware: status `0x02`, read-back exact, and the change is
+ * felt at the sensor, which a read-back alone cannot establish.
+ */
+export declare function razerSetLiftOffCommand(liftOff: number, landing: number): RazerCommand;
+/**
+ * Legacy polling encodes the rate as a divisor of 1000, so it cannot express
+ * the HyperPolling rates. Wireless answers this command as unsupported.
+ */
+export declare function decodeLegacyPollingRate(args: Uint8Array): number;
+/**
+ * HyperPolling rates encode as a divisor of 8000. The first reply byte echoes
+ * the request argument, so the rate lives in the second. Wired answers this
+ * command as unsupported.
+ */
+export declare function decodeExtendedPollingRate(args: Uint8Array): number;
+/**
+ * The four controls the button-mapping write has been confirmed against, on
+ * the Viper V3 Pro's Standard layer. Left Click and Right Click use standard
+ * USB HID button numbering (1, 2), confirmed physically rather than assumed —
+ * writing Mouse Button 4's slot with each index and pressing it produced a
+ * real left-click and right-click. Mouse Button 4/5 matched their Synapse
+ * names directly. Cross-assignable among each other, plus Disabled.
+ *
+ * Scroll Up, Scroll Down and the bottom sensitivity button ship too, but as a
+ * separate, narrower kind of control — see `RazerToggleControl`. Scroll Click
+ * and Hypershift remain unshipped: Scroll Click's index is known but this
+ * driver's own write to it has only been physically checked against the wrong
+ * action, and Hypershift's read does not honour a requested layer at all.
+ */
+export type RazerButtonControl = "leftClick" | "rightClick" | "mouse4" | "mouse5";
+export declare const RAZER_BUTTON_CONTROLS: readonly RazerButtonControl[];
+/** Every mapping the panel can offer: each control's own action, plus Disabled. */
+export declare const RAZER_BUTTON_MAPPINGS: readonly ["Left Click", "Right Click", "Mouse Button 4", "Mouse Button 5", "Disabled"];
+export type RazerButtonMapping = (typeof RAZER_BUTTON_MAPPINGS)[number];
+export declare const RAZER_BUTTON_CONTROL_LABEL: Record<RazerButtonControl, RazerButtonMapping>;
+/**
+ * Decodes a button-mapping reply back to a label. Returns null for an
+ * encoding this driver does not recognise — a keyboard shortcut, a control
+ * outside the four shipped here, or anything else unmapped — so a caller can
+ * preserve it rather than misrepresent it as one of the known five.
+ */
+export declare function razerDecodeButtonMapping(args: Uint8Array): RazerButtonMapping | null;
+/** Only the Standard layer is trusted for reads — see `RAZER_READ.buttonMapping`. */
+export declare function razerReadButtonMappingCommand(control: RazerButtonControl): RazerCommand;
+/**
+ * Left Click cannot be reassigned or disabled on the Standard layer — Synapse
+ * enforces the same restriction, presumably because it is the only reliable
+ * way to interact with Windows (and with Synapse itself) at all. Exported so
+ * the UI can disable the control outright instead of letting a user hit the
+ * error.
+ */
+export declare const RAZER_LOCKED_BUTTON_CONTROL: RazerButtonControl;
+export declare function razerSetButtonMappingCommand(control: RazerButtonControl, mapping: RazerButtonMapping): RazerCommand;
+/**
+ * Scroll Up, Scroll Down and the bottom sensitivity button, each restricted
+ * to exactly two states: their own factory action, or Disabled. Unlike
+ * `RazerButtonControl`, these are not cross-assignable — assigning one of
+ * these an action from `RAZER_BUTTON_MAPPINGS`, or assigning a button one of
+ * these controls' actions, has never been attempted on hardware and is not
+ * exposed here. Deliberately a separate type from `RazerButtonControl` and
+ * kept out of `RAZER_BUTTON_MAPPINGS` for that reason, even though three of
+ * these four values would otherwise fit the same plain-action shape.
+ *
+ * Each control's enabled state is a fixed, opaque payload captured verbatim
+ * from the mouse rather than something constructed from a shared formula,
+ * because the bottom sensitivity button's default ("Cycle Up Sensitivity
+ * Stages") is not a plain-button action at all — `actionType=0x06`, a type
+ * this driver otherwise never decodes.
+ *
+ * Scroll Click (index `0x03`) is deliberately not included: its index is
+ * known and Synapse's own disable was physically confirmed, but the one
+ * physical test run against this driver's own write to that index checked
+ * the wrong result (scroll-down instead of the click), so it has not
+ * separately cleared this driver's own bar yet.
+ */
+export type RazerToggleControl = "scrollUp" | "scrollDown" | "sensitivityButton";
+export declare const RAZER_TOGGLE_CONTROLS: readonly RazerToggleControl[];
+export interface RazerToggleControlInfo {
+    index: number;
+    /** Display heading for the control itself, independent of its current state. */
+    label: string;
+    /** The label for this control's one non-Disabled state. */
+    enabledLabel: string;
+    /** `[actionType, actionLen, actionValue]` for the enabled state, captured verbatim from the mouse. */
+    enabledArgs: readonly [number, number, number];
+}
+export declare const RAZER_TOGGLE_CONTROL_INFO: Record<RazerToggleControl, RazerToggleControlInfo>;
+/** Only the Standard layer is trusted for reads — see `RAZER_READ.buttonMapping`. */
+export declare function razerReadToggleControlCommand(control: RazerToggleControl): RazerCommand;
+/**
+ * Decodes a toggle control's reply to its own enabled label or "Disabled".
+ * Returns null for anything else — Hypershift data, a Synapse reassignment
+ * this driver has never captured, or noise — so a caller can preserve it
+ * rather than misrepresent it as one of the two known states.
+ */
+export declare function razerDecodeToggleControl(control: RazerToggleControl, args: Uint8Array): string | null;
+export declare function razerSetToggleControlCommand(control: RazerToggleControl, label: string): RazerCommand;
+//# sourceMappingURL=codec.d.ts.map

package/dist/razer/codec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec.d.ts","sourceRoot":"","sources":["../../src/razer/codec.ts"],"names":[],"mappings":"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"}