@honeybbq/teamspeak 1.0.0-beta.19 → 1.0.0-beta.21

package/src/core/api/files.ts

@@ -37,10 +37,6 @@ import type {
 import { asClientFileTransferID, asClientID, asServerFileTransferID } from "../command/ids.js";
 import type { FileDownloadInfo, FileUploadInfo } from "../types.js";
 
-/** The `ip` of a negotiation answer, when the server sent one. */
-const ipField = (row: Record<string, string>): { readonly ip?: string } =>
-  str(row, "ip") === "" ? {} : { ip: str(row, "ip") };
-
 const asPath = (path: string): string => (path.startsWith("/") ? path : `/${path}`);
 
 /** One entry of a directory listing, or one file's details. */
@@ -109,9 +105,10 @@ export interface FileTreeEntry extends FileEntry {
 /** How {@link listFilesRecursive} walks the file area. */
 export interface FileTreeOptions extends FileOptions {
   /**
-   * How many directory levels to go down from the starting path: 0 lists the
-   * starting directory only, as {@link listFiles} does; 1 also lists the
-   * directories in it; and so on. 16 by default. A non-negative integer.
+   * How many directory levels to list, counted as `find -maxdepth` counts: 1
+   * lists the starting directory only, as {@link listFiles} does; 2 also lists
+   * the directories in it; and so on. 16 by default; there is no unbounded
+   * walk, since every level is a round trip. A positive integer.
    */
   readonly maxDepth?: number | undefined;
 }
@@ -148,8 +145,8 @@ export async function listFilesRecursive(
   options: FileTreeOptions = {},
 ): Promise<FileTreeEntry[]> {
   const { maxDepth = DEFAULT_MAX_DEPTH, ...listOptions } = options;
-  if (!Number.isInteger(maxDepth) || maxDepth < 0) {
-    throw new RangeError(`maxDepth is a non-negative integer, not ${String(maxDepth)}`);
+  if (!Number.isInteger(maxDepth) || maxDepth < 1) {
+    throw new RangeError(`maxDepth is a positive integer, not ${String(maxDepth)}`);
   }
   const found: FileTreeEntry[] = [];
   const walk = async (directory: string, depth: number): Promise<void> => {
@@ -159,7 +156,7 @@ export async function listFilesRecursive(
       if (entry.isDirectory && depth < maxDepth) await walk(entryPath, depth + 1);
     }
   };
-  await walk(asPath(path), 0);
+  await walk(asPath(path), 1);
   return found;
 }
 
@@ -299,7 +296,11 @@ export interface FileTransferStopOptions extends CommandOptions {
  * Stop only your own transfers: TeamSpeak 6 6.0.0-beta13.1 crashes on a
  * ServerQuery `ftstop` for a transfer that is not the connection's own (one
  * that does not exist, or another client's), and nothing here guards against
- * it. See "Server behaviour the SDK works around" in `docs/serverquery-responses.md`.
+ * it. A transfer of your own is gone once it has finished, or when nobody
+ * connected to it within about 10 seconds of its being negotiated (measured on
+ * TeamSpeak 3 3.13.8 and TeamSpeak 6 6.0.0), so stopping it then crashes
+ * TeamSpeak 6 too. See "Server behaviour the SDK works around" in
+ * `docs/serverquery-responses.md`.
  */
 export async function stopFileTransfer(
   client: CommandExecutor,
@@ -395,7 +396,14 @@ export interface FileUploadOptions extends CommandOptions {
    * destroys a file unless asked to (`overwrite`, always sent).
    */
   readonly overwrite?: boolean | undefined;
-  /** Continue a partial upload; false by default (`resume`). */
+  /**
+   * Continue a partial upload; false by default (`resume`). The server keeps
+   * what an interrupted upload had received, and `seekPosition` of the answer
+   * is how much that is: send the file from there. Measured on TeamSpeak 3
+   * 3.13.8 and TeamSpeak 6 6.0.0: resuming a file that is not there is refused
+   * with 2054 (invalid file path), and `overwrite` together with `resume` with
+   * 2056 (overwrite excludes resume).
+   */
   readonly resume?: boolean | undefined;
 }
 
@@ -436,10 +444,10 @@ export async function initFileUpload(
   return {
     fileTransferKey: str(row, "ftkey"),
     port: num(row, "port"),
+    size,
     seekPosition: big(row, "seekpos"),
     clientFileTransferID: asClientFileTransferID(uint(row, "clientftfid", U16)),
     serverFileTransferID: asServerFileTransferID(uint(row, "serverftfid", U16)),
-    ...ipField(row),
   };
 }
 
@@ -447,7 +455,12 @@ export async function initFileUpload(
 export interface FileDownloadOptions extends CommandOptions {
   /** The channel's password, in cleartext; "" by default (`cpw`). */
   readonly password?: string | undefined;
-  /** The byte offset to start from, to resume; 0 by default (`seekpos`). */
+  /**
+   * The byte offset to start from, to resume; 0 by default (`seekpos`). The
+   * answer's `size` stays the whole file's, and the bytes sent are those from
+   * here to the end; an offset past the end is refused with 2057 (invalid file
+   * size), measured on TeamSpeak 3 3.13.8 and TeamSpeak 6 6.0.0.
+   */
   readonly seekPosition?: bigint | undefined;
 }
 
@@ -463,6 +476,7 @@ export async function initFileDownload(
   path: string,
   options: FileDownloadOptions = {},
 ): Promise<FileDownloadInfo> {
+  const seekPosition = options.seekPosition ?? 0n;
   const rows = await query(
     client,
     "ftinitdownload",
@@ -471,7 +485,7 @@ export async function initFileDownload(
       ["name", asPath(path)],
       ["cid", cid],
       ["cpw", options.password ?? ""],
-      ["seekpos", options.seekPosition ?? 0n],
+      ["seekpos", seekPosition],
       ["proto", 0],
     ],
     options,
@@ -482,8 +496,8 @@ export async function initFileDownload(
     fileTransferKey: str(row, "ftkey"),
     port: num(row, "port"),
     size: big(row, "size"),
+    seekPosition,
     clientFileTransferID: asClientFileTransferID(uint(row, "clientftfid", U16)),
     serverFileTransferID: asServerFileTransferID(uint(row, "serverftfid", U16)),
-    ...ipField(row),
   };
 }

package/src/core/api/groups.ts

@@ -408,7 +408,10 @@ export async function getPermissionIDByName(
  * What a permission is set on, as `permfind` and `permoverview` report it:
  * discriminated on `target`, so each kind carries its own typed ids. The wire
  * sends them as `t`, `id1` and `id2`, whose meaning depends on `t`; a row with
- * a target this table does not name is left out of the results.
+ * a target this table does not name is passed through as the last kind, with
+ * the number and the raw ids. Narrowing on `target` therefore leaves that
+ * kind in the union: compare `target` with {@link PermissionTarget} and
+ * handle the rest in a default case.
  */
 export type PermissionLocation =
   | {
@@ -454,10 +457,20 @@ export type PermissionLocation =
       readonly databaseID: ClientDBID;
       /** The permission (`p`). */
       readonly permission: PermissionID;
+    }
+  | {
+      /** Set on something this table does not name: the number the server sent (`t`). */
+      readonly target: number;
+      /** The first id as sent (`id1`); what it names depends on `target`. */
+      readonly id1: bigint;
+      /** The second id as sent (`id2`). */
+      readonly id2: bigint;
+      /** The permission (`p`). */
+      readonly permission: PermissionID;
     };
 
-/** Read a location from a `permfind` or `permoverview` row; undefined for an unknown target. */
-function parseLocation(row: Record<string, string>): PermissionLocation | undefined {
+/** Read a location from a `permfind` or `permoverview` row. */
+function parseLocation(row: Record<string, string>): PermissionLocation {
   const permission = asPermissionID(uint(row, "p", U32));
   const id1 = big(row, "id1");
   const id2 = big(row, "id2");
@@ -487,7 +500,7 @@ function parseLocation(row: Record<string, string>): PermissionLocation | undefi
         permission,
       };
     default:
-      return undefined;
+      return { target: num(row, "t"), id1, id2, permission };
   }
 }
 
@@ -498,7 +511,7 @@ export async function findPermission(
   options?: CommandOptions,
 ): Promise<PermissionLocation[]> {
   const rows = await list(client, "permfind", [permissionParam(permission)], options);
-  return rows.flatMap((row) => parseLocation(row) ?? []);
+  return rows.map(parseLocation);
 }
 
 /** One of this connection's own permissions, as `permget` reports it. */
@@ -573,11 +586,12 @@ export async function getPermissionOverview(
     ],
     options,
   );
-  return rows.flatMap((row) => {
-    const location = parseLocation(row);
-    if (location === undefined) return [];
-    return [{ ...location, value: num(row, "v"), negated: bool(row, "n"), skip: bool(row, "s") }];
-  });
+  return rows.map((row) => ({
+    ...parseLocation(row),
+    value: num(row, "v"),
+    negated: bool(row, "n"),
+    skip: bool(row, "s"),
+  }));
 }
 
 /**
@@ -605,7 +619,10 @@ export interface PrivilegeKey {
   readonly token: string;
   /** Which kind of group the key grants, one of {@link PrivilegeKeyType}. */
   readonly type: number;
-  /** The server group a `PrivilegeKeyType.ServerGroup` key grants; undefined otherwise. */
+  /**
+   * The server group a `PrivilegeKeyType.ServerGroup` key grants; undefined
+   * for any other type, including one this SDK does not name.
+   */
   readonly serverGroupID: ServerGroupID | undefined;
   /** The channel group a `PrivilegeKeyType.ChannelGroup` key grants; undefined otherwise. */
   readonly channelGroupID: ChannelGroupID | undefined;
@@ -625,15 +642,17 @@ export interface PrivilegeKey {
 /**
  * Read a key. The wire carries the group as `token_id1` and the channel as
  * `token_id2`, whichever kind of group it is; which typed field each belongs in
- * depends on the token type.
+ * depends on the token type. A type this SDK does not name gets neither group
+ * nor channel: what its ids mean is not known.
  */
 const parseKey = (row: Record<string, string>): PrivilegeKey => {
   const type = num(row, "token_type");
   const channelGroup = type === PrivilegeKeyType.ChannelGroup;
+  const serverGroup = type === PrivilegeKeyType.ServerGroup;
   return {
     token: str(row, "token"),
     type,
-    serverGroupID: channelGroup ? undefined : asServerGroupID(big(row, "token_id1")),
+    serverGroupID: serverGroup ? asServerGroupID(big(row, "token_id1")) : undefined,
     channelGroupID: channelGroup ? asChannelGroupID(big(row, "token_id1")) : undefined,
     channelID: channelGroup ? asChannelID(big(row, "token_id2")) : undefined,
     description: str(row, "token_description"),

package/src/core/api/parse.ts

@@ -45,39 +45,40 @@ const flag = (key: string): FieldSpec<boolean> => ({ keys: [key], read: bool });
 /**
  * The wire key of every client field but `id`, and how each is read: the one
  * table `parseClient` and `parseClientChanges` share, so a row, a listing and
- * a change cannot disagree about a name. `always` marks the fields a full
- * record has had from the start, which read as a default from a row without
- * them; every other field is left out when the row lacks it.
+ * a change cannot disagree about a name. `always` marks the fields every
+ * source carries, which read as a default from a row without them; every
+ * other field is left out when the row lacks it.
  */
 export const clientFields: {
   readonly [K in Exclude<keyof ClientEntry, "id">]-?: FieldSpec<ClientEntry[K]>;
 } = {
   nickname: { keys: ["client_nickname"], read: str, always: true },
-  uid: { keys: ["client_unique_identifier"], read: (r, k) => asUID(str(r, k)), always: true },
   // A listing names the channel `cid`, an enter notification `ctid`.
   channelID: { keys: ["cid", "ctid"], read: (r, k) => asChannelID(big(r, k)), always: true },
   type: { keys: ["client_type"], read: num, always: true },
+  uid: { keys: ["client_unique_identifier"], read: (r, k) => asUID(str(r, k)) },
   serverGroups: {
     keys: ["client_servergroups"],
     read: (r, k) => parseServerGroups(r[k] ?? ""),
-    always: true,
   },
-  isAway: { keys: ["client_away"], read: bool, always: true },
-  isRecording: { keys: ["client_is_recording"], read: bool, always: true },
-  isTalker: { keys: ["client_is_talker"], read: bool, always: true },
+  isAway: flag("client_away"),
+  isRecording: flag("client_is_recording"),
+  isTalker: flag("client_is_talker"),
   channelGroupID: {
     keys: ["client_channel_group_id"],
     read: (r, k) => asChannelGroupID(big(r, k)),
-    always: true,
   },
-  createdAt: { keys: ["client_created"], read: date, always: true },
-  lastConnectedAt: { keys: ["client_lastconnected"], read: date, always: true },
+  createdAt: { keys: ["client_created"], read: date },
+  lastConnectedAt: { keys: ["client_lastconnected"], read: date },
   idleTimeMs: {
     keys: ["client_idle_time"],
-    read: (r, k) => (r[k] === undefined ? undefined : durationMs(r, k, MILLISECOND)),
+    read: (r, k) => durationMs(r, k, MILLISECOND),
+  },
+  databaseID: {
+    keys: ["client_database_id"],
+    read: (r, k) => asClientDBID(big(r, k)),
     always: true,
   },
-  databaseID: { keys: ["client_database_id"], read: (r, k) => asClientDBID(big(r, k)) },
   awayMessage: text("client_away_message"),
   isInputMuted: flag("client_input_muted"),
   isOutputMuted: flag("client_output_muted"),
@@ -120,8 +121,8 @@ export const clientFields: {
  * which names its channel `ctid` where the list says `cid`. Reached by the
  * client module through `./internal`.
  *
- * The fields a client record has always had read as a default from a row
- * without them; the later ones are `undefined` instead.
+ * The fields every source carries read as a default from a row without
+ * them; the others are `undefined` instead.
  */
 export function parseClient(row: Record<string, string>): ClientEntry {
   return {

package/src/core/command/request.ts

@@ -40,6 +40,12 @@ export interface CommandOptions {
   readonly signal?: AbortSignal | undefined;
   /** Milliseconds to wait for the answer before failing with a CommandTimeoutError. */
   readonly timeoutMs?: number | undefined;
+  /**
+   * Called once, when the command has left the flood throttle and was handed to
+   * the connection. A command that fails without it was never sent; one that
+   * fails after it may have been carried out.
+   */
+  readonly onSent?: (() => void) | undefined;
 }
 
 /**
@@ -96,6 +102,13 @@ export function encodeRequest(
   return [line, ...rest.map((row) => buildCommandOrdered("", encode(row)).slice(1))].join("|");
 }
 
+/**
+ * A parameter name: letters, digits and underscores, with one leading `-` for a
+ * flag such as `-uid`. Every key measured on TeamSpeak 3 and 6, in a command or
+ * an answer, is of this form.
+ */
+const VALID_KEY = /^-?[A-Za-z0-9_]+$/;
+
 function encodeParams(
   params: ReadonlyArray<readonly [string, ParamValue]>,
   passwords: readonly string[],
@@ -103,6 +116,11 @@ function encodeParams(
 ): Array<readonly [string, string]> {
   const out: Array<readonly [string, string]> = [];
   for (const [key, value] of params) {
+    // A key is a protocol identifier, written to the line as it is: one with a
+    // space, a newline or a pipe in it would add parameters, rows or a whole
+    // command to what the caller meant. Only a key a server could have named
+    // is sent.
+    if (!VALID_KEY.test(key)) throw new TypeError(`${JSON.stringify(key)} is not a parameter name`);
     // Flags (`-uid`) are switches: present when true, absent otherwise.
     if (key.startsWith("-")) {
       if (value === true) out.push([key, ""]);

package/src/core/errors.ts

@@ -231,13 +231,78 @@ export class NoDataError extends TeamspeakError {
 }
 
 /**
- * Read an error id. One that is missing or unreadable is reported as
- * {@link ErrorCode.Undefined}: an error line that does not say what went wrong
- * has still not said that nothing did.
+ * `raw` as an unsigned 32-bit number, or undefined unless it is nothing but
+ * digits and fits: "12abc", " 7", "-1" and "4294967296" are not numbers the
+ * server sends, and are not read as 12, 7, 1 or a code no one defined.
+ */
+function parseUint32(raw: string | undefined): number | undefined {
+  if (raw === undefined || !/^\d+$/.test(raw)) return undefined;
+  const value = Number(raw);
+  return value <= 0xffff_ffff ? value : undefined;
+}
+
+/**
+ * Read an error id. One that is missing or unreadable (not an unsigned 32-bit
+ * number) is reported as {@link ErrorCode.Undefined}: an error line that does
+ * not say what went wrong has still not said that nothing did.
  */
 export function parseErrorCode(raw: string | undefined): number {
-  if (raw === undefined || !/^\d+$/.test(raw)) return ErrorCode.Undefined;
-  return Number(raw);
+  return parseUint32(raw) ?? ErrorCode.Undefined;
+}
+
+/**
+ * How many times a command refused as flooding is sent again after the pause
+ * the server asked for. On the voice protocol the first resend is usually
+ * refused once more with a shorter wait, and the second goes through (measured
+ * on TeamSpeak 3 and 6); on ServerQuery a refusal can be answered with a
+ * longer wait, which the caller's timeout then decides whether to sit out.
+ */
+export const FLOOD_RETRIES = 3;
+/**
+ * How long to pause for a refusal that asked for `waitMs`. The wait is a floor:
+ * on the voice protocol a resend after exactly the wait is refused again, and
+ * one after half as long again goes through; on ServerQuery a resend after
+ * exactly 1 second was refused 2 times in 5, and one after 2.2 seconds went
+ * through 5 times in 5 (TeamSpeak 3 3.13.8 and TeamSpeak 6 6.0.0). Every
+ * refusal costs a retry and lengthens the server's pause, so the pause is
+ * twice the wait.
+ */
+export function floodHoldMs(waitMs: number): number {
+  return waitMs * 2;
+}
+
+/**
+ * How long the server asks a client it refused as flooding to wait, in
+ * milliseconds. Undefined for any other error, or one that names no wait.
+ *
+ * Measured on TeamSpeak 3 3.13.8 and TeamSpeak 6 6.0.0: a voice client whose
+ * antiflood points pass `virtualserver_antiflood_points_needed_command_block`
+ * gets `error id=524 msg=client\sis\sflooding extra_msg=retry\sin\s1985ms`
+ * for each command, and the command is not run. The wait is a floor, not a
+ * promise: a command sent as the wait ends is refused again with a shorter one,
+ * and the second try went through in every measurement.
+ *
+ * A ServerQuery client (raw TCP and SSH; over WebQuery the server closes the
+ * connection and says nothing) that sends faster than
+ * `serverinstance_serverquery_flood_commands` per `_flood_time` gets the same
+ * error with the wait in whole seconds,
+ * `extra_msg=please\swait\s1\sseconds`, and the command is not run. The first
+ * refusals say 1; later ones say the instance's
+ * `serverinstance_serverquery_ban_time`, as the address is banned for that long
+ * (new connections are dropped meanwhile). Asking again every half second kept
+ * the ban going for as long as it was kept up (9 seconds against a ban time of
+ * 4), while waiting out the pause and asking once got through. The wait is a
+ * floor here too: about one resend in three after exactly the wait was refused
+ * again, with the ban time.
+ */
+export function floodRetryDelayMs(error: Error): number | undefined {
+  if (!(error instanceof ServerError) || error.code !== ErrorCode.ClientIsFlooding)
+    return undefined;
+  const extra = error.extraMessage ?? "";
+  const millis = /^retry in (\d{1,9})ms$/.exec(extra);
+  if (millis !== null) return Number(millis[1]);
+  const seconds = /^please wait (\d{1,9}) seconds$/.exec(extra);
+  return seconds === null ? undefined : Number(seconds[1]) * 1000;
 }
 
 /**
@@ -249,28 +314,17 @@ export function parseServerError(params: Record<string, string>): {
   rc: number | null;
 } {
   const code = parseErrorCode(params["id"]);
-  const rcStr = params["return_code"];
 
   let err: ServerError | null = null;
   if (code !== ErrorCode.OK) {
-    const failedPermid = params["failed_permid"];
+    const failedPermid = parseUint32(params["failed_permid"]);
     err = new ServerError(code, params["msg"] ?? "", {
       extraMessage: params["extra_msg"] || undefined,
-      failedPermissionID:
-        failedPermid !== undefined &&
-        /^\d{1,10}$/.test(failedPermid) &&
-        Number(failedPermid) <= 0xffff_ffff
-          ? asPermissionID(Number(failedPermid))
-          : undefined,
+      failedPermissionID: failedPermid === undefined ? undefined : asPermissionID(failedPermid),
       failedPermission: params["failed_permission"] || undefined,
     });
   }
 
-  let rc: number | null = null;
-  if (rcStr !== undefined && rcStr !== "") {
-    const parsed = parseInt(rcStr, 10);
-    if (!isNaN(parsed)) rc = parsed;
-  }
-
-  return { err, rc };
+  // A return code that is not an unsigned 32-bit number names no command.
+  return { err, rc: parseUint32(params["return_code"]) ?? null };
 }

package/src/core/events.ts

@@ -20,6 +20,11 @@ export interface TextMessageEvent {
    * The sender's server groups. A text message does not carry them; they are
    * those of the sender as the client knows it, so they are `undefined` for a
    * sender the client has not seen.
+   *
+   * A ServerQuery connection is not sent `notifyclientupdated`, so for a query
+   * client they are the groups from the listing taken on connecting, kept
+   * current only by clients entering, leaving and moving: a change of groups
+   * made since is not in them.
    */
   readonly invokerGroups: readonly ServerGroupID[] | undefined;
   /**
@@ -38,15 +43,21 @@ export interface TextMessageEvent {
 
 /** A client changing channel, of its own accord or moved by someone. */
 export interface ClientMovedEvent {
-  /** Who moved the client; the client itself for a move of its own. */
+  /**
+   * Who moved the client; "" when the server names no one, which it does not
+   * for a move of the client's own (reason 0).
+   */
   readonly invokerName: string;
-  /** The mover's unique identifier. */
+  /** The mover's unique identifier; "" when none is named. */
   readonly invokerUID: UID;
   /** The channel the client is now in. */
   readonly targetChannelID: ChannelID;
   /**
-   * The channel the client came from (`cfid`). Absent when the server sends
-   * none: TS3 3.13.8 sends no `cfid` on a move, TS6 6.0.0-beta13.1 does.
+   * The channel the client came from: `cfid`, or when the server sends none
+   * (TS3 3.13.8 sends no `cfid` on a move, TS6 6.0.0 does) the channel the
+   * client was known to be in. Absent only when the server sent none and the
+   * client was not known. A client's own roster entry is updated before the
+   * event is delivered, so this is the only place the previous channel is.
    */
   readonly fromChannelID?: ChannelID | undefined;
   /** Why the client moved; compare it with `Reason`. */
@@ -55,7 +66,7 @@ export interface ClientMovedEvent {
   readonly reasonMessage: string;
   /** The client that moved. */
   readonly clientID: ClientID;
-  /** The mover. */
+  /** The mover; 0 when the server names no one, as for a move of the client's own. */
   readonly invokerID: ClientID;
 }
 
@@ -113,8 +124,9 @@ export interface KickedEvent {
 /**
  * A client coming into view: the record `listClients` returns, so one type
  * describes a client however it was learned of, with what only the
- * notification says. Its own id is `id`, as in every record. The fields only
- * `clientlist -times` reports are undefined here.
+ * notification says. Its own id is `id`, as in every record. The notification
+ * carries every field but the ones only `clientlist` reports (`-times`,
+ * `-info`, `-ip`), which are undefined here.
  *
  * `fromChannelID` and `reason` belong to the event: the roster and
  * `view.clients` keep the record without them.
@@ -365,7 +377,11 @@ export interface VoiceDataEvent {
    * server may relay a codec that table does not name.
    */
   readonly codec: number;
-  /** One encoded frame, copied: it stays valid after the listener returns. */
+  /**
+   * One encoded frame, copied: it stays valid after the listener returns. Empty
+   * when the speaker stopped talking: it is the end of that speech, not a
+   * frame to decode.
+   */
   readonly data: Uint8Array;
 }
 

package/src/core/internal.ts

@@ -20,6 +20,12 @@ export type { NotificationResult } from "./notifications.js";
 export { parseIconID } from "./command/ids.js";
 export { responseSpec } from "./command/responses.js";
 export type { ResponseSpec } from "./command/responses.js";
-export { parseErrorCode, parseServerError } from "./errors.js";
+export {
+  floodHoldMs,
+  FLOOD_RETRIES,
+  floodRetryDelayMs,
+  parseErrorCode,
+  parseServerError,
+} from "./errors.js";
 export { splitCommandRows, parseUint64, parseUint16, parseInt10, sleep } from "./helpers.js";
 export { jitteredDelay, resolveBackoffPolicy } from "./reconnect.js";

package/src/core/notifications.ts

@@ -81,7 +81,7 @@ export type NotificationResult =
  * client's own id (0 when it is not known yet), and `clients` the clients the
  * caller knows, which the enter, leave, move, update and channel group
  * notifications keep current and the others read: a text message carries no
- * groups, and a move of the client's own carries no invoker. An entry is
+ * groups, and a move carries no `cfid` on TS3. An entry is
  * replaced, never edited, so an event that holds one stays as it was.
  *
  * The server-group notifications leave the clients alone: the update that
@@ -214,22 +214,23 @@ function handleClientMoved(cmd: Command, clients: Map<number, ClientEntry>): Not
   const existing = clients.get(clid);
   if (existing) clients.set(clid, { ...existing, channelID: ctid });
 
-  // A move the client made itself names no invoker, so the fields are empty;
-  // the client it knows by `clid` is who that was.
-  const invokerID = asClientID(parseUint16(cmd.params["invokerid"] ?? ""));
-  const invoker = clients.get(invokerID === 0 ? clid : invokerID);
+  // Where the client came from: `cfid` when the server sends it, and when it
+  // does not (TS3 sends none on a move) the channel the roster had it in,
+  // which this notification is about to replace.
+  const from = cmd.params["cfid"] === undefined ? existing?.channelID : undefined;
 
+  // A move the client made itself (reason 0) names no invoker, and the fields
+  // are left empty: it is not filled in from the roster.
   return {
     kind: "clientMoved",
     event: {
       clientID: clid,
       targetChannelID: ctid,
       ...channelOf(cmd.params, "cfid", "fromChannelID"),
+      ...(from === undefined ? {} : { fromChannelID: from }),
       reason: parseInt10(cmd.params["reasonid"] ?? ""),
       reasonMessage: cmd.params["reasonmsg"] ?? "",
-      invokerID,
-      invokerName: cmd.params["invokername"] ?? invoker?.nickname ?? "",
-      invokerUID: asUID(cmd.params["invokeruid"] ?? invoker?.uid ?? ""),
+      ...invoked(cmd.params),
     },
   };
 }