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

package/src/client/transfer.ts

@@ -8,7 +8,7 @@
 
 import { connect } from "node:net";
 import { pipeline } from "node:stream/promises";
-import { Transform, type Duplex, type Readable, type Writable } from "node:stream";
+import { Transform, Writable, type Duplex, type Readable } from "node:stream";
 import type { FileUploadInfo, FileDownloadInfo } from "@honeybbq/teamspeak";
 import type { FileTransferSocketFactory } from "./types.js";
 import { FileTransferError } from "./errors.js";
@@ -25,6 +25,25 @@ const DEFAULT_IDLE_TIMEOUT_MS = 30_000;
 /** How many bytes move between two calls of the `progress` hook, at least. */
 const PROGRESS_STEP_BYTES = 64 * 1024;
 
+/** The file transfer ports a connection can be made to. */
+const MAX_PORT = 65535;
+
+/**
+ * The errors of dials that failed before the connection opened. Nothing has
+ * reached the server then: not the key, and no byte of the file.
+ */
+const failedBeforeConnect = new WeakSet();
+
+/**
+ * Whether `error` is a dial that never got a connection: refused, unreachable,
+ * or timed out while connecting. Not one the caller's signal or the idle limit
+ * ended, nor one after the connection opened, where the key may have been
+ * written and the server may hold or have dropped the transfer.
+ */
+export function failedToConnect(error: unknown): boolean {
+  return typeof error === "object" && error !== null && failedBeforeConnect.has(error);
+}
+
 /** Where a failed transfer failed. */
 export type FileTransferStage = "dial" | "transfer";
 
@@ -48,7 +67,7 @@ export interface FileTransferDialDoneInfo {
 export interface FileTransferProgressInfo {
   /** The bytes moved so far. */
   readonly bytes: number;
-  /** The size the negotiation gave; 0 when it is not known, as for an upload. */
+  /** The bytes the transfer will move, as the negotiation fixed them. */
   readonly total: number;
 }
 
@@ -218,6 +237,9 @@ async function dial(
   idle: IdleGuard,
 ): Promise<Duplex> {
   const { signal, socketFactory } = options;
+  if (!Number.isInteger(port) || port < 1 || port > MAX_PORT) {
+    throw new FileTransferError(`the file transfer port is ${String(port)}, not 1 to ${MAX_PORT}`);
+  }
   // One budget for the connection and the key write: a peer that accepts the
   // connection and never reads would otherwise hold the write forever.
   const timeout = AbortSignal.timeout(DIAL_TIMEOUT_MS);
@@ -233,8 +255,10 @@ async function dial(
   // report: a stream's unhandled `error` event takes the process down.
   const swallow = (): void => {};
   socket.on("error", swallow);
+  let open = false;
   try {
     await abortable(connected(socket), dialSignal);
+    open = true;
     idle.touch();
     await abortable(
       new Promise<void>((resolve, reject) => {
@@ -254,7 +278,11 @@ async function dial(
   } catch (error) {
     socket.destroy();
     if (timeout.aborted && error === timeout.reason) {
-      throw new FileTransferError("file transfer connection timed out", { cause: error });
+      const timedOut = new FileTransferError("file transfer connection timed out", {
+        cause: error,
+      });
+      if (!open) failedBeforeConnect.add(timedOut);
+      throw timedOut;
     }
     throw error;
   } finally {
@@ -293,9 +321,10 @@ function countingStream(t: TransferTrace, total: number, idle: IdleGuard): Trans
 
 /**
  * Passes exactly `expected` bytes. One more byte fails the transfer, and is
- * not passed on; a stream that ends before `expected` fails it too.
+ * not passed on; a stream that ends before `expected` fails it too. `what`
+ * says who fixed the size, for the message.
  */
-function exactSize(expected: number): Transform {
+function exactSize(expected: number, what: "announced" | "declared"): Transform {
   let received = 0;
   return new Transform({
     transform(chunk: Buffer, _encoding, callback) {
@@ -304,7 +333,7 @@ function exactSize(expected: number): Transform {
         this.push(chunk.subarray(0, room));
         received = expected;
         callback(
-          new FileTransferError(`file transfer sent more than the announced ${expected} bytes`),
+          new FileTransferError(`file transfer sent more than the ${what} ${expected} bytes`),
         );
         return;
       }
@@ -316,7 +345,7 @@ function exactSize(expected: number): Transform {
         received === expected
           ? null
           : new FileTransferError(
-              `file transfer ended after ${received} of the announced ${expected} bytes`,
+              `file transfer ended after ${received} of the ${what} ${expected} bytes`,
             ),
       );
     },
@@ -330,11 +359,7 @@ async function transfer(
   key: string,
   total: number,
   options: FileTransferOptions,
-  move: (
-    socket: Duplex,
-    counter: Transform,
-    pipeOptions: { signal?: AbortSignal },
-  ) => Promise<void>,
+  move: (socket: Duplex, counter: Transform, pipeOptions: { signal: AbortSignal }) => Promise<void>,
 ): Promise<void> {
   const t = newTransferTrace(options);
   const idle = newIdleGuard(options);
@@ -356,6 +381,10 @@ async function transfer(
       const failure = idleOr(idle, error);
       reportFailed(t, failure, "transfer");
       throw failure;
+    } finally {
+      // The server ends a transfer it has finished, and a failed one is
+      // abandoned here; either way nothing is left to keep the socket for.
+      socket.destroy();
     }
   } finally {
     idle.stop();
@@ -386,50 +415,165 @@ function connected(socket: Duplex): Promise<void> {
       else reject(error);
     };
     const onConnect = (): void => done();
-    const onError = (error: Error): void =>
-      done(
-        new FileTransferError(`file transfer connection failed: ${error.message}`, {
-          cause: error,
-        }),
-      );
+    const onError = (error: Error): void => {
+      const failure = new FileTransferError(`file transfer connection failed: ${error.message}`, {
+        cause: error,
+      });
+      failedBeforeConnect.add(failure);
+      done(failure);
+    };
     socket.once("connect", onConnect);
     socket.once("ready", onConnect);
     socket.once("error", onError);
   });
 }
 
-/** Upload `data` over a negotiated transfer. Resolves once every byte is sent. */
-export function uploadFileData(
+/**
+ * How many bytes a negotiated transfer moves: the file's size less the
+ * position it starts from.
+ */
+function bytesToMove(size: bigint, seekPosition: bigint): number {
+  if (seekPosition < 0n || seekPosition > size) {
+    throw new FileTransferError(
+      `the transfer starts at ${seekPosition}, outside a file of ${size} bytes`,
+    );
+  }
+  return Number(size - seekPosition);
+}
+
+/**
+ * A sink that hands what it is given to `dest`, one write at a time, without
+ * ever ending it: the stream is the caller's, and may take more transfers.
+ * `dest`'s errors fail the sink, so the pipeline sees them.
+ */
+function intoStream(dest: Writable): Writable {
+  const sink = new Writable({
+    write(chunk: Buffer, _encoding, callback) {
+      dest.write(chunk, callback);
+    },
+  });
+  const onError = (error: Error): void => {
+    sink.destroy(error);
+  };
+  dest.on("error", onError);
+  // A failed `dest` reports its error a tick after the write that failed, by
+  // which time this sink is closed: keep listening until that has been said.
+  sink.on("close", () => setImmediate(() => dest.off("error", onError)));
+  return sink;
+}
+
+/**
+ * The same for a socket that is not to be ended: an upload is over when the
+ * server says so, not when the last byte has left.
+ */
+function intoSocket(socket: Duplex): Writable {
+  // A write after the server closed the connection fails with the socket's own
+  // error (EPIPE, or "ended by the other party"): the transfer's failure.
+  const failure = (error: Error): FileTransferError =>
+    new FileTransferError(`file transfer connection failed: ${error.message}`, {
+      cause: error,
+    });
+  const sink = new Writable({
+    write(chunk: Buffer, _encoding, callback) {
+      socket.write(chunk, (error) => callback(error ? failure(error) : null));
+    },
+  });
+  socket.on("error", (error: Error) => {
+    sink.destroy(failure(error));
+  });
+  return sink;
+}
+
+/** Resolves once the server has closed the transfer connection. */
+function serverClosed(socket: Duplex, signal: AbortSignal): Promise<void> {
+  if (socket.readableEnded || socket.destroyed) return Promise.resolve();
+  const closed = new Promise<void>((resolve, reject) => {
+    const done = (error?: Error): void => {
+      socket.off("end", onEnd);
+      socket.off("close", onEnd);
+      socket.off("error", done);
+      if (error === undefined) resolve();
+      else reject(error);
+    };
+    const onEnd = (): void => done();
+    socket.once("end", onEnd);
+    socket.once("close", onEnd);
+    socket.once("error", done);
+  });
+  // Nothing is sent back, but the end of the stream is only seen by reading.
+  socket.resume();
+  return abortable(closed, signal);
+}
+
+/**
+ * Upload `data` over a negotiated transfer. `data` is the file from
+ * `info.seekPosition` on, and must give exactly the bytes left of
+ * `info.size`: a stream that gives fewer or more fails the transfer.
+ *
+ * Resolves once the server has closed the transfer connection, which it does
+ * when it has the file. Measured on TeamSpeak 3 3.13.8 and TeamSpeak 6 6.0.0:
+ * the server closes about 200 ms after the last byte of a 100 000-byte file,
+ * and at once after the declared size when more is sent. A connection that
+ * closes before every byte is written, or that stays open for the idle limit,
+ * fails the transfer.
+ *
+ * A close after the last byte is not proof that the file is stored: the server
+ * sends nothing on the transfer connection, and over the voice protocol its
+ * `notifystatusfiletransfer` comes only for a failure (2066 canceled, 2063
+ * lost connection, 2052 more than declared), after the close, never for
+ * success; over ServerQuery nothing comes. `uploadFile` therefore asks the
+ * server for the file's size with `ftgetfileinfo` before it resolves.
+ */
+export async function uploadFileData(
   host: string,
   info: FileUploadInfo,
   data: Readable,
   options: FileTransferOptions = {},
 ): Promise<void> {
-  return transfer(
+  const expected = bytesToMove(info.size, info.seekPosition);
+  await transfer(
     host,
     info.port,
     info.fileTransferKey,
-    0,
+    expected,
     options,
-    (socket, counter, pipeOptions) => pipeline(data, counter, socket, pipeOptions),
+    async (socket, counter, pipeOptions) => {
+      await pipeline(
+        data,
+        exactSize(expected, "declared"),
+        counter,
+        intoSocket(socket),
+        pipeOptions,
+      );
+      await serverClosed(socket, pipeOptions.signal);
+    },
   );
 }
 
-/** Download a negotiated transfer into `dest`. Resolves once the file is written. */
-export function downloadFileData(
+/**
+ * Download a negotiated transfer into `dest`. Resolves once the file is
+ * written; `dest` is not ended, so it may take another download.
+ *
+ * A download from `info.seekPosition` brings the bytes from there to the end
+ * of the file: measured on TeamSpeak 3 3.13.8 and TeamSpeak 6 6.0.0, a
+ * `seekpos` of 40 000 on a 100 000-byte file is answered with the whole size
+ * and then 60 000 bytes.
+ */
+export async function downloadFileData(
   host: string,
   info: FileDownloadInfo,
   dest: Writable,
   options: FileTransferOptions = {},
 ): Promise<void> {
-  return transfer(
+  const expected = bytesToMove(info.size, info.seekPosition);
+  await transfer(
     host,
     info.port,
     info.fileTransferKey,
-    Number(info.size),
+    expected,
     options,
     (socket, counter, pipeOptions) =>
-      pipeline(socket, exactSize(Number(info.size)), counter, dest, pipeOptions),
+      pipeline(socket, exactSize(expected, "announced"), counter, intoStream(dest), pipeOptions),
   );
 }
 

package/src/client/transport/handler.ts

@@ -14,7 +14,7 @@ import {
   buildC2SHeader,
   parseS2CHeader,
 } from "./packet.js";
-import { ConnectionTimeoutError } from "../errors.js";
+import { ConnectionStalledError, ConnectionTimeoutError } from "../errors.js";
 import { abortable, abortReason } from "../abort.js";
 import { NotConnectedError, TeamspeakError } from "@honeybbq/teamspeak";
 import { GenerationWindow } from "./generation-window.js";
@@ -40,6 +40,12 @@ const WHISPER_HEADER_SIZE = 5;
 const GROUP_WHISPER_HEADER_SIZE = 13;
 const RESEND_BASE_INTERVAL_MS = 500;
 const RESEND_LOOP_INTERVAL_MS = 100;
+/**
+ * How long a command packet may stay missing while later ones wait for it. The
+ * server sends a command again until it is acknowledged, so a hole that stays
+ * this long is not going to fill.
+ */
+const COMMAND_HOLE_TIMEOUT_MS = 5_000;
 
 /**
  * The largest command reassembled from fragments. The receive window already
@@ -88,6 +94,12 @@ interface ResendPacket {
   lastSend: number;
   retryCount: number;
   nextInterval: number;
+  /**
+   * Whether the packet went out under the dummy key. Fixed at the first send:
+   * clientek is sent under it and crypto init completes right after, so a
+   * resend that chose again would use a key the server cannot decrypt with.
+   */
+  dummy: boolean;
 }
 
 export class PacketHandler {
@@ -542,6 +554,7 @@ export class PacketHandler {
       lastSend: performance.now(),
       retryCount: 0,
       nextInterval: RESEND_BASE_INTERVAL_MS,
+      dummy,
     };
     this.#trackResend(pType, p, rp);
   }
@@ -582,7 +595,6 @@ export class PacketHandler {
     const ciphertext = raw.slice(TAG_SIZE + 3);
 
     const parsed = parseS2CHeader(header);
-    this.#traffic.recordReceived(parsed.typeFlagged & 0x0f, raw.length, performance.now());
     // Init1 belongs to the start of the handshake; once crypto init has
     // completed, another one can only restart a session that is already set up.
     const parsedType: PacketType = parsed.typeFlagged & 0x0f;
@@ -604,6 +616,7 @@ export class PacketHandler {
     // Only a packet that decrypted shows the server is there: anyone can send
     // datagrams that do not, and they must not keep a dead session alive.
     this.#lastMessageReceived = performance.now();
+    this.#traffic.recordReceived(pType, raw.length, p.receivedAt);
 
     if (pType === PacketType.Pong && p.data.length >= 2) {
       const acked = new DataView(p.data.buffer, p.data.byteOffset).getUint16(0, false);
@@ -747,9 +760,12 @@ export class PacketHandler {
     }
     const queue = pType === PacketType.Command ? this.#commandQueue : this.#commandLowQueue;
     const held = queue.get(p.id)?.data.length ?? 0;
-    // The packet the queue waits for is always taken: it is what drains it.
-    const next = pType === PacketType.Command ? this.#nextCommandID : this.#nextCommandLowID;
-    if (p.id !== next && this.#queuedBytes - held + p.data.length > MAX_QUEUED_BYTES) {
+    // The packet the queue needs next, the first id from the next expected one
+    // that it does not hold, is always taken: it is what drains it, and what
+    // lets a command larger than the queue reach its last fragment.
+    let needed = pType === PacketType.Command ? this.#nextCommandID : this.#nextCommandLowID;
+    for (let i = 0; i < queue.size && queue.has(needed); i++) needed = (needed + 1) & 0xffff;
+    if (p.id !== needed && this.#queuedBytes - held + p.data.length > MAX_QUEUED_BYTES) {
       // Not acknowledged: the server sends it again.
       this.#logger.debug("dropped a command packet: the receive queues are full", { id: p.id });
       return false;
@@ -783,12 +799,6 @@ export class PacketHandler {
 
     this.#hold(queue, p);
 
-    if (isCommand) {
-      this.#fastForwardMissingPackets(queue, win, true);
-    } else {
-      this.#fastForwardMissingPackets(queue, win, false);
-    }
-
     while (true) {
       const current = isCommand ? this.#nextCommandID : this.#nextCommandLowID;
       const packet = queue.get(current);
@@ -827,18 +837,17 @@ export class PacketHandler {
   #nextCommandID = 0;
   #nextCommandLowID = 0;
 
-  #fastForwardMissingPackets(
-    queue: Map<number, Packet>,
-    win: GenerationWindow,
-    isCommand: boolean,
-  ): void {
-    let nextID = isCommand ? this.#nextCommandID : this.#nextCommandLowID;
-    while (!queue.has(nextID) && hasOldNewerPacket(queue, nextID)) {
-      nextID = (nextID + 1) & 0xffff;
-      win.advance(1);
+  /**
+   * Whether a command packet is missing from `queue` while a later one has
+   * waited for it for COMMAND_HOLE_TIMEOUT_MS.
+   */
+  #hasStalledHole(queue: Map<number, Packet>, nextID: number, now: number): boolean {
+    if (queue.has(nextID)) return false;
+    for (const [id, pkg] of queue) {
+      const diff = (id - nextID + 0x10000) & 0xffff;
+      if (diff < 0x8000 && now - pkg.receivedAt > COMMAND_HOLE_TIMEOUT_MS) return true;
     }
-    if (isCommand) this.#nextCommandID = nextID;
-    else this.#nextCommandLowID = nextID;
+    return false;
   }
 
   #tryReassemble(
@@ -859,22 +868,14 @@ export class PacketHandler {
     let startSeen = false;
 
     // Ends at the fragment that closes the command, or returns while one is
-    // still missing.
+    // still missing. The size is checked once the whole command is there, so an
+    // oversize one is released to its end marker and never leaves the stream
+    // part-way through a command.
     while (true) {
       const frag = queue.get(currID);
       if (!frag) return null;
       fragments.push(frag);
       totalSize += frag.data.length;
-      if (totalSize > MAX_REASSEMBLED_SIZE) {
-        // Dropped whole, so the window moves past it rather than waiting on
-        // the rest of a command that will never be accepted.
-        for (let i = 0; i < fragments.length; i++) {
-          this.#release(queue, nextID);
-          win.advance(1);
-          nextID = (nextID + 1) & 0xffff;
-        }
-        return [null, nextID];
-      }
 
       const fragmented = (packetFlags(frag) & PacketFlags.Fragmented) !== 0;
       if (!startSeen) {
@@ -886,6 +887,16 @@ export class PacketHandler {
       currID = (currID + 1) & 0xffff;
     }
 
+    if (totalSize > MAX_REASSEMBLED_SIZE) {
+      // Dropped whole, so the window moves past it.
+      for (let i = 0; i < fragments.length; i++) {
+        this.#release(queue, nextID);
+        win.advance(1);
+        nextID = (nextID + 1) & 0xffff;
+      }
+      return [null, nextID];
+    }
+
     const combined = new Uint8Array(totalSize);
     let pos = 0;
     for (const frag of fragments) {
@@ -971,6 +982,15 @@ export class PacketHandler {
       return;
     }
 
+    if (
+      this.#hasStalledHole(this.#commandQueue, this.#nextCommandID, now) ||
+      this.#hasStalledHole(this.#commandLowQueue, this.#nextCommandLowID, now)
+    ) {
+      this.#logger.warn("a command from the server never arrived");
+      this.#triggerClose(new ConnectionStalledError());
+      return;
+    }
+
     if (this.#initPacketCheck) {
       this.#doResend(this.#initPacketCheck, now);
     }
@@ -993,7 +1013,6 @@ export class PacketHandler {
     this.#resends++;
     rp.nextInterval = Math.min(rp.nextInterval * 2, MAX_RETRY_INTERVAL_MS);
 
-    const dummy = !this.#crypt.cryptoInitComplete;
     const unencrypted = (packetFlags(rp.packet) & PacketFlags.Unencrypted) !== 0;
     const header = buildC2SHeader(rp.packet);
     const pType = packetType(rp.packet);
@@ -1004,7 +1023,7 @@ export class PacketHandler {
       rp.packet.generationID,
       header,
       rp.packet.data,
-      dummy,
+      rp.dummy,
       unencrypted,
     );
 
@@ -1039,14 +1058,3 @@ function applyProtocolFlags(pType: PacketType, flags: number): number {
   }
   return flags;
 }
-
-function hasOldNewerPacket(queue: Map<number, Packet>, nextID: number): boolean {
-  const now = performance.now();
-  for (const [id, pkg] of queue) {
-    const diff = (id - nextID + 0x10000) & 0xffff;
-    if (diff < 0x8000 && now - pkg.receivedAt > 5_000) {
-      return true;
-    }
-  }
-  return false;
-}

package/src/core/api/clients.ts

@@ -58,43 +58,46 @@ export interface ClientEntry {
   readonly id: ClientID;
   /** The client's nickname. */
   readonly nickname: string;
-  /** The client's unique identifier, stable across connections. Empty if `uid` was turned off. */
-  readonly uid: UID;
-  /** The channel the client is in. */
-  readonly channelID: ChannelID;
-  /** What kind of connection this is, one of {@link ClientType}. */
+  /** What kind of connection this is, one of {@link ClientType}; every source carries it. */
   readonly type: number;
+  /** The channel the client is in; every source carries it. */
+  readonly channelID: ChannelID;
+  /** The client's database id (`client_database_id`); every list and every enter notification carries it. */
+  readonly databaseID: ClientDBID;
+
+  // Everything below is `undefined` when the row did not carry its key, never
+  // a default: a client that is not away and one whose away state was not asked
+  // for are different, and `false` would claim the first. `clientlist` carries
+  // only what its flags bring, and a client coming into view carries all but
+  // the fields said to be missing there. Which list flag brings a field is said
+  // on it; "no flag" means only a client coming into view (or a notification)
+  // has it, so a client learned from `listClients` never does.
+
+  /** The client's unique identifier, stable across connections, with `uid`. Empty is a client that has none. */
+  readonly uid?: UID | undefined;
   /**
    * The server groups the client holds, with `groups`. Ids rather than names:
    * the server sends ids, and resolving them costs a separate call.
    */
-  readonly serverGroups: readonly ServerGroupID[];
+  readonly serverGroups?: readonly ServerGroupID[] | undefined;
   /** Whether the client is away, with `away`. */
-  readonly isAway: boolean;
+  readonly isAway?: boolean | undefined;
   /** Whether the client is recording, with `voice`. */
-  readonly isRecording: boolean;
+  readonly isRecording?: boolean | undefined;
   /** Whether the client may talk despite the channel's needed talk power, with `voice`. */
-  readonly isTalker: boolean;
+  readonly isTalker?: boolean | undefined;
   /** The channel group the client holds in its channel, with `groups`. */
-  readonly channelGroupID: ChannelGroupID;
+  readonly channelGroupID?: ChannelGroupID | undefined;
   /** When the client first connected to this server, with `times`. */
-  readonly createdAt: Date | undefined;
+  readonly createdAt?: Date | undefined;
   /** When the client last connected before this session, with `times`. */
-  readonly lastConnectedAt: Date | undefined;
+  readonly lastConnectedAt?: Date | undefined;
   /**
    * How long since the client last did anything, in milliseconds
    * (`client_idle_time`), with `times`; undefined without it.
    */
-  readonly idleTimeMs: number | undefined;
-
-  // Everything below is `undefined` when the row did not carry its key, never
-  // a default: a muted client and one whose mute state is unknown are
-  // different, and `false` would claim the first. Which list flag brings a
-  // field is said on it; "no flag" means only a client coming into view (or a
-  // notification) has it, so a client learned from `listClients` never does.
+  readonly idleTimeMs?: number | undefined;
 
-  /** The client's database id (`client_database_id`); every list brings it. */
-  readonly databaseID?: ClientDBID | undefined;
   /** The away message (`client_away_message`), with `away`. */
   readonly awayMessage?: string | undefined;
   /** Whether the microphone is muted (`client_input_muted`), with `voice`. */

package/src/core/api/command.ts

@@ -577,12 +577,6 @@ export interface Channel {
   readonly name: string;
   /** The topic shown under the name (`channel_topic`). */
   readonly topic: string;
-  /**
-   * The description (`channel_description`). `channellist` does not carry it,
-   * so `listChannels` leaves it empty; `getChannelInfo` or the voice client's
-   * `getChannelDescription` has it.
-   */
-  readonly description: string;
   /**
    * The channel this one is sorted after among its siblings, or 0 for the
    * first: `channel_order` is a channel id, not a position.
@@ -645,6 +639,14 @@ export interface Channel {
   // undefined; `getChannelInfo` fills it in, and a created or edited
   // notification names the ones that changed.
 
+  /**
+   * The description (`channel_description`). Neither `channellist` nor a
+   * channel notification carries it, so `listChannels` and the voice client's
+   * view leave it undefined, and a channel's description changing is told by
+   * `channelDescriptionChanged` without the text; `getChannelInfo` has it, and
+   * so has the voice client's `getChannelDescription`.
+   */
+  readonly description?: string | undefined;
   /** How many packets of voice are sent at once, 1 to 10 (`channel_codec_latency_factor`). */
   readonly codecLatencyFactor?: number | undefined;
   /** Whether voice in the channel travels unencrypted (`channel_codec_is_unencrypted`). */
@@ -722,7 +724,7 @@ export const channelFields: {
   },
   name: { keys: ["channel_name"], read: str, always: true },
   topic: { keys: ["channel_topic"], read: str, always: true },
-  description: { keys: ["channel_description"], read: str, always: true },
+  description: { keys: ["channel_description"], read: str },
   order: { keys: ["channel_order"], read: (row, key) => asChannelID(big(row, key)), always: true },
   hasPassword: { keys: ["channel_flag_password"], read: bool, always: true },
   isDefault: { keys: ["channel_flag_default"], read: bool, always: true },