@honeybbq/teamspeak 0.0.1 → 1.0.0-beta.7

package/src/client/handshake/crypt-handshake.ts

@@ -0,0 +1,157 @@
+import { randomBytes } from "node:crypto";
+import { buildCommandOrdered } from "../../core/internal.js";
+import type { Crypt } from "../crypto/crypt.js";
+import { HandshakeError } from "../errors.js";
+
+export const INIT_VERSION = 1566914096; // 3.5.0 [Stable]
+
+const INIT_VERSION_LEN = 4;
+const INIT_TYPE_LEN = 1;
+const INIT_STEP_LEN = 21;
+
+/** The RSA challenge each connection attempt, by its Crypt, has answered. */
+const answeredChallenges = new WeakMap<
+  Crypt,
+  {
+    readonly challenge: Uint8Array;
+    readonly answer: Uint8Array;
+    readonly level: number;
+    readonly durationMs: number;
+  }
+>();
+
+/**
+ * The RSA puzzle `crypt`'s attempt solved: the level the server demanded and
+ * the milliseconds spent on it. Level 0 and no time when the server sent none.
+ */
+export function puzzleOf(crypt: Crypt): { readonly level: number; readonly durationMs: number } {
+  const answered = answeredChallenges.get(crypt);
+  return { level: answered?.level ?? 0, durationMs: answered?.durationMs ?? 0 };
+}
+
+/**
+ * Handle the TS3INIT1 handshake steps.
+ * Returns the response bytes to send, or null if nothing should be sent.
+ * Throws a HandshakeError for a step that cannot be answered.
+ */
+export function processInit1(crypt: Crypt, data: Uint8Array | null): Uint8Array | null {
+  if (data === null || (data.length >= 1 && data[0] === 0x7f)) {
+    return buildInit1StartPacket();
+  }
+  if (data.length === 0) throw new HandshakeError("empty Init1 packet");
+
+  switch (data[0]) {
+    case 0:
+      return buildInit1Step1Packet(data);
+    case 1:
+      return buildInit1Step2Packet(data);
+    case 2:
+      return buildInit1Step3Packet(data);
+    case 3:
+      return buildInit1Step4Packet(crypt, data);
+    case undefined:
+    default:
+      return null;
+  }
+}
+
+function buildInit1StartPacket(): Uint8Array {
+  const sendData = new Uint8Array(INIT_VERSION_LEN + INIT_TYPE_LEN + 4 + 4 + 8);
+  const view = new DataView(sendData.buffer);
+
+  view.setUint32(0, INIT_VERSION, false);
+  sendData[4] = 0x00;
+
+  const nowSec = Math.floor(Date.now() / 1000);
+  const clampedNow = Math.max(0, Math.min(nowSec, 0xffff_ffff));
+  view.setUint32(5, clampedNow, false);
+
+  const rng = randomBytes(4);
+  sendData.set(rng, 9);
+
+  return sendData;
+}
+
+function buildInit1Step1Packet(data: Uint8Array): Uint8Array | null {
+  if (data.length !== INIT_STEP_LEN) return null;
+
+  const sendData = new Uint8Array(INIT_TYPE_LEN + 16 + 4);
+  sendData[0] = 0x01;
+
+  // TS rand: little-endian uint32 at offset [INIT_VERSION_LEN + INIT_TYPE_LEN + 4]
+  const tsRandOffset = INIT_VERSION_LEN + INIT_TYPE_LEN + 4;
+  const tsRand =
+    data[tsRandOffset]! |
+    (data[tsRandOffset + 1]! << 8) |
+    (data[tsRandOffset + 2]! << 16) |
+    (data[tsRandOffset + 3]! << 24);
+
+  new DataView(sendData.buffer).setUint32(INIT_TYPE_LEN + 16, tsRand >>> 0, false);
+  return sendData;
+}
+
+function buildInit1Step2Packet(data: Uint8Array): Uint8Array | null {
+  if (data.length !== INIT_STEP_LEN) return null;
+
+  const sendData = new Uint8Array(INIT_VERSION_LEN + INIT_TYPE_LEN + 16 + 4);
+  new DataView(sendData.buffer).setUint32(0, INIT_VERSION, false);
+  sendData[4] = 0x02;
+  sendData.set(data.slice(1, 21), 5);
+  return sendData;
+}
+
+function buildInit1Step3Packet(data: Uint8Array): Uint8Array | null {
+  if (data.length !== INIT_VERSION_LEN + INIT_TYPE_LEN + 16 + 4) return null;
+
+  const sendData = new Uint8Array(INIT_TYPE_LEN + 64 + 64 + 4 + 100);
+  sendData[0] = 0x03;
+  sendData[INIT_TYPE_LEN + 64 - 1] = 1;
+  sendData[INIT_TYPE_LEN + 64 + 64 - 1] = 1;
+  new DataView(sendData.buffer).setUint32(INIT_TYPE_LEN + 64 + 64, 1, false);
+  return sendData;
+}
+
+function buildInit1Step4Packet(crypt: Crypt, data: Uint8Array): Uint8Array | null {
+  if (data.length !== INIT_TYPE_LEN + 64 + 64 + 4 + 100) return null;
+  // One challenge per connection attempt, whose Crypt is its own. Each answer
+  // costs up to a second of synchronous squarings, and a second would choose a
+  // new alpha behind the clientinitiv already sent. The same challenge again
+  // means the server did not get our answer, so it gets the same answer,
+  // without solving anything; a different one gets none.
+  const answered = answeredChallenges.get(crypt);
+  if (answered !== undefined) {
+    return Buffer.from(answered.challenge).equals(Buffer.from(data)) ? answered.answer : null;
+  }
+
+  const level = new DataView(data.buffer, data.byteOffset).getUint32(1 + 128, false);
+  const solveStarted = performance.now();
+  const y = crypt.solveRsaChallenge(data, 1, level);
+  const durationMs = performance.now() - solveStarted;
+
+  const alphaB64 = Buffer.from(crypt.newAlpha()).toString("base64");
+  const omegaB64 = crypt.identity.publicKey();
+
+  const cmd = buildCommandOrdered("clientinitiv", [
+    ["alpha", alphaB64],
+    ["omega", omegaB64],
+    ["ot", "1"],
+    ["ip", ""],
+  ]);
+  const cmdBytes = Buffer.from(cmd);
+
+  const sendData = new Uint8Array(INIT_VERSION_LEN + INIT_TYPE_LEN + 232 + 64 + cmdBytes.length);
+  const view = new DataView(sendData.buffer);
+  view.setUint32(0, INIT_VERSION, false);
+  sendData[4] = 0x04;
+  sendData.set(data.slice(1, 233), 5);
+  sendData.set(y.slice(0, 64), 5 + 232);
+  sendData.set(cmdBytes, 5 + 232 + 64);
+
+  answeredChallenges.set(crypt, {
+    challenge: Uint8Array.from(data),
+    answer: sendData,
+    level,
+    durationMs,
+  });
+  return sendData;
+}

package/src/client/handshake/crypt-init2.ts

@@ -0,0 +1,48 @@
+import type { KeyObject } from "node:crypto";
+import type { Crypt } from "../crypto/crypt.js";
+import { importPublicKey } from "../crypto/identity.js";
+import { verifySign, getSharedSecret2 } from "../crypto/primitives.js";
+import { parseLicenses } from "./license.js";
+import { HandshakeError } from "../errors.js";
+
+/**
+ * CryptoInit2 performs the second stage of crypto initialization (Ed25519 ECDH).
+ * Mirrors Go's handshake.CryptoInit2.
+ */
+export function cryptoInit2(
+  crypt: Crypt,
+  license: string,
+  omega: string,
+  proof: string,
+  beta: string,
+  privateKey: Uint8Array,
+): void {
+  if (crypt.alpha.length === 0) {
+    throw new HandshakeError("initivexpand2 arrived before clientinitiv was sent");
+  }
+
+  const licenseBytes = Buffer.from(license, "base64");
+  const omegaBytes = Buffer.from(omega, "base64");
+  const proofBytes = Buffer.from(proof, "base64");
+  const betaBytes = Buffer.from(beta, "base64");
+
+  let serverPubKey: KeyObject;
+  try {
+    serverPubKey = importPublicKey(omegaBytes);
+  } catch (error) {
+    throw new HandshakeError("the server's public key is invalid", { cause: error });
+  }
+  if (!verifySign(serverPubKey, licenseBytes, proofBytes)) {
+    throw new HandshakeError("the server's license proof is not valid");
+  }
+
+  let sharedSecret: Uint8Array;
+  try {
+    const key = parseLicenses(licenseBytes).deriveKey();
+    sharedSecret = getSharedSecret2(key, privateKey);
+  } catch (error) {
+    throw new HandshakeError("the server's license is invalid", { cause: error });
+  }
+
+  crypt.setSharedSecret(crypt.alpha, betaBytes, sharedSecret);
+}

package/src/client/handshake/index.ts

@@ -0,0 +1,3 @@
+export { processInit1, INIT_VERSION } from "./crypt-handshake.js";
+export { cryptoInit2 } from "./crypt-init2.js";
+export { LicenseChain, parseLicenses } from "./license.js";

package/src/client/handshake/license.ts

@@ -0,0 +1,208 @@
+import { hash512 } from "../crypto/identity.js";
+import { clampScalar, scalarMultFull, bytesToBigIntLE } from "../crypto/primitives.js";
+import { ed25519 } from "@noble/curves/ed25519.js";
+
+// The root key is a 33-byte Ed25519 point
+const LICENSE_ROOT_KEY = new Uint8Array([
+  0xcd, 0x0d, 0xe2, 0xae, 0xd4, 0x63, 0x45, 0x50, 0x9a, 0x7e, 0x3c, 0xfd, 0x8f, 0x68, 0xb3, 0xdc,
+  0x75, 0x55, 0xb2, 0x9d, 0xcc, 0xec, 0x73, 0xcd, 0x18, 0x75, 0x0f, 0x99, 0x38, 0x12, 0x40, 0x8a,
+]);
+
+const enum LicenseBlockType {
+  Intermediate = 0,
+  Server = 2,
+  Ts5Server = 8,
+  Ephemeral = 32,
+}
+
+interface LicenseBlock {
+  readonly key: Uint8Array; // 32-byte Ed25519 point
+  readonly hash: Uint8Array; // SHA-512 truncated to 32 bytes
+  properties: Uint8Array[];
+  issuer: string;
+  notValidBefore: Date;
+  notValidAfter: Date;
+  blockType: LicenseBlockType;
+  serverType: number;
+}
+
+export class LicenseChain {
+  readonly blocks: LicenseBlock[];
+
+  constructor(blocks: LicenseBlock[]) {
+    this.blocks = blocks;
+  }
+
+  /**
+   * Derive the session key by chaining Ed25519 point arithmetic starting from
+   * the root key through each license block.
+   */
+  deriveKey(): Uint8Array<ArrayBuffer> {
+    let round: Uint8Array<ArrayBuffer> = Uint8Array.from(LICENSE_ROOT_KEY);
+    for (const block of this.blocks) {
+      round = deriveKeyFromBlock(block, round);
+    }
+    return round;
+  }
+}
+
+/**
+ * The most blocks a license chain may have. Real chains have two or three —
+ * root-issued intermediate, server, ephemeral — and every block costs a
+ * point multiplication to derive, so a server's chain of thousands would hold
+ * the event loop for seconds.
+ */
+export const MAX_LICENSE_BLOCKS = 8;
+
+export function parseLicenses(data: Uint8Array): LicenseChain {
+  if (data.length < 1) throw new Error("license too short");
+  if (data[0] !== 1) throw new Error("unsupported license version");
+
+  let remaining = data.slice(1);
+  const blocks: LicenseBlock[] = [];
+
+  while (remaining.length > 0) {
+    if (blocks.length === MAX_LICENSE_BLOCKS) {
+      throw new Error(`license chain longer than ${MAX_LICENSE_BLOCKS} blocks`);
+    }
+    const { block, consumed } = parseLicenseBlock(remaining);
+    blocks.push(block);
+    remaining = remaining.slice(consumed);
+  }
+
+  return new LicenseChain(blocks);
+}
+
+function parseLicenseBlock(data: Uint8Array): { block: LicenseBlock; consumed: number } {
+  const MIN_BLOCK_LEN = 42;
+  if (data.length < MIN_BLOCK_LEN) throw new Error("license too short");
+  if (data[0] !== 0) throw new Error(`wrong key kind in license: ${data[0]}`);
+
+  const blockType = data[33] as LicenseBlockType;
+
+  // Timestamps are seconds since Unix epoch offset by 0x50e22700
+  const UNIX_OFFSET = 0x50e22700;
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const notValidBefore = new Date((view.getUint32(34, false) + UNIX_OFFSET) * 1000);
+  const notValidAfter = new Date((view.getUint32(38, false) + UNIX_OFFSET) * 1000);
+
+  if (notValidAfter < notValidBefore) {
+    throw new Error("license times are invalid");
+  }
+
+  const key = Uint8Array.from(data.slice(1, 33));
+
+  const { payload, payloadRead } = parseBlockPayload(blockType, data, MIN_BLOCK_LEN);
+
+  const allLen = MIN_BLOCK_LEN + payloadRead;
+  if (allLen > data.length) throw new Error("license block longer than the license");
+  const hashInput = data.slice(1, allLen);
+  const hashFull = hash512(Uint8Array.from(hashInput));
+  const hash = Uint8Array.from(hashFull.slice(0, 32));
+
+  return {
+    block: {
+      key,
+      hash,
+      properties: payload.properties,
+      issuer: payload.issuer,
+      notValidBefore,
+      notValidAfter,
+      blockType,
+      serverType: payload.serverType,
+    },
+    consumed: allLen,
+  };
+}
+
+interface BlockPayload {
+  issuer: string;
+  serverType: number;
+  properties: Uint8Array[];
+  read: number;
+}
+
+function parseBlockPayload(
+  blockType: LicenseBlockType,
+  data: Uint8Array,
+  minBlockLen: number,
+): { payload: BlockPayload; payloadRead: number } {
+  switch (blockType) {
+    case LicenseBlockType.Intermediate: {
+      const { str, read } = readNullString(data.slice(46));
+      return {
+        payload: { issuer: str, serverType: 0, properties: [], read: 5 + read },
+        payloadRead: 5 + read,
+      };
+    }
+    case LicenseBlockType.Server: {
+      const { str, read } = readNullString(data.slice(47));
+      return {
+        payload: { issuer: str, serverType: data[42] ?? 0, properties: [], read: 6 + read },
+        payloadRead: 6 + read,
+      };
+    }
+    case LicenseBlockType.Ts5Server: {
+      const propCount = data[43] !== undefined ? data[43] : 0;
+      let pos = 44;
+      const properties: Uint8Array[] = [];
+      for (let i = 0; i < propCount; i++) {
+        if (pos >= data.length) throw new Error("license too short");
+        const propLen = data[pos++]!;
+        if (pos + propLen > data.length) throw new Error("license too short");
+        properties.push(Uint8Array.from(data.slice(pos, pos + propLen)));
+        pos += propLen;
+      }
+      return {
+        payload: { issuer: "", serverType: data[42] ?? 0, properties, read: pos - minBlockLen },
+        payloadRead: pos - minBlockLen,
+      };
+    }
+    case LicenseBlockType.Ephemeral:
+      return { payload: { issuer: "", serverType: 0, properties: [], read: 0 }, payloadRead: 0 };
+    default:
+      throw new Error(`invalid license block type: ${String(blockType)}`);
+  }
+}
+
+/**
+ * Scan for a null-terminated string and return its content and the index
+ * of the null byte (NOT including it in the count, matching Go behaviour).
+ * The parent formulas (`5 + read`, `6 + read`) already add 1 for the null.
+ */
+function readNullString(data: Uint8Array): { str: string; read: number } {
+  for (let i = 0; i < data.length; i++) {
+    if (data[i] === 0) {
+      return { str: new TextDecoder().decode(data.slice(0, i)), read: i };
+    }
+  }
+  throw new Error("non-null-terminated issuer string");
+}
+
+/**
+ * Derive the next key given a parent key and a license block.
+ * Mirrors Go's licenseBlock.deriveKey.
+ */
+function deriveKeyFromBlock(block: LicenseBlock, parent: Uint8Array): Uint8Array<ArrayBuffer> {
+  const scalarBytes = Uint8Array.from(block.hash);
+  clampScalar(scalarBytes);
+
+  // Use raw scalar WITHOUT reducing mod n — NaCl's ge_scalarmult_vartime
+  // uses the raw 256-bit scalar. Reducing mod n changes the result when
+  // the point has a small-order component (Ed25519 cofactor = 8).
+  const scalar = bytesToBigIntLE(scalarBytes);
+
+  const pub = ed25519.Point.fromBytes(block.key);
+  const negPub = pub.negate();
+
+  const par = ed25519.Point.fromBytes(parent);
+  const negPar = par.negate();
+
+  const res = scalarMultFull(negPub, scalar).add(negPar);
+  const raw = res.toBytes();
+  const final = new Uint8Array(raw.length);
+  final.set(raw);
+  final[31] = (final[31] !== undefined ? final[31] : 0) ^ 0x80;
+
+  return final;
+}

package/src/client/handshake.ts

@@ -0,0 +1,150 @@
+import { createHash } from "node:crypto";
+import { buildCommandOrdered, buildCommand } from "../core/internal.js";
+import { sign, generateTemporaryKey } from "./crypto/primitives.js";
+import { identityPrivateKey } from "./crypto/identity.js";
+import { parseServerCapabilities } from "./capabilities.js";
+import { cryptoInit2 } from "./handshake/crypt-init2.js";
+import { PacketType } from "./transport/packet.js";
+import type { ClientVersion } from "@honeybbq/teamspeak";
+import type { ClientInternals } from "./client.js";
+
+/** Handle the `clientinitiv` message (P-256 based crypto path). */
+export function handleHandshakeInitIV(
+  client: ClientInternals,
+  params: Record<string, string>,
+): void {
+  const alpha = params["alpha"] ?? "";
+  const beta = params["beta"] ?? "";
+  const omega = params["omega"] ?? "";
+
+  client.handler.receivedFinalInitAck();
+  client.crypt.initCrypto(alpha, beta, omega);
+  client.markHandshakeDone(omega);
+  client.logger.info("crypto initialized (P-256 path), sending clientinit");
+  sendClientInit(client);
+}
+
+/** Handle the `initivexpand2` message (Ed25519 / TS3 crypto path). */
+export function handleHandshakeExpand2(
+  client: ClientInternals,
+  params: Record<string, string>,
+): void {
+  client.logger.info("received initivexpand2");
+  client.handler.receivedFinalInitAck();
+
+  const license = params["l"] ?? "";
+  const omega = params["omega"] ?? "";
+  const proof = params["proof"] ?? "";
+  const beta = params["beta"] ?? "";
+
+  const privateKey = sendClientEkPacket(client, beta);
+  cryptoInit2(client.crypt, license, omega, proof, beta, privateKey);
+  client.markHandshakeDone(omega);
+  sendClientInit(client);
+}
+
+/** Handle `initserver` — marks the client as connected. */
+export function handleInitServer(client: ClientInternals, params: Record<string, string>): void {
+  const idStr = params["aclid"] ?? params["clid"] ?? "";
+  const clid = idStr ? parseInt(idStr, 10) : 0;
+
+  if (clid > 0) {
+    client.clid = clid;
+    client.handler.setClientID(clid);
+  }
+
+  // initserver is the only place the server names itself, and it determines how
+  // the server hashes our public key into client_unique_identifier: SHA-1 on
+  // TS3, SHA-256 on TS6. Recording the whole capability set here keeps callers
+  // from re-deriving it, or assuming one server generation.
+  client.capabilities = parseServerCapabilities(params);
+
+  client.logger.info("connected to server", { selfId: client.clid });
+  client.markConnected(params);
+
+  // Inform the server about mute state
+  setImmediate(() => {
+    const updateCmd = buildCommand("clientupdate", {
+      client_input_muted: "0",
+      client_output_muted: "0",
+    });
+    client.execNoWait(updateCmd).catch(() => {});
+  });
+}
+
+function sendClientEkPacket(client: ClientInternals, beta: string): Uint8Array {
+  const [publicKey, privateKey] = generateTemporaryKey();
+  const ekBase64 = Buffer.from(publicKey).toString("base64");
+  const clientProof = buildClientEkProof(client, publicKey, beta);
+
+  const clientEk = buildCommandOrdered("clientek", [
+    ["ek", ekBase64],
+    ["proof", clientProof],
+  ]);
+  client.handler.sendPacket(PacketType.Command, Buffer.from(clientEk), 0);
+  return privateKey;
+}
+
+function buildClientEkProof(client: ClientInternals, publicKey: Uint8Array, beta: string): string {
+  const betaBytes = Buffer.from(beta, "base64");
+  const toSign = new Uint8Array(86);
+  toSign.set(publicKey.subarray(0, 32));
+  toSign.set(betaBytes.subarray(0, Math.min(54, betaBytes.length)), 32);
+  const sig = sign(identityPrivateKey(client.crypt.identity), toSign);
+  return Buffer.from(sig).toString("base64");
+}
+
+/**
+ * Encode a password field for the command protocol.
+ *
+ * TeamSpeak expects password fields as base64(sha1(password)) — server and
+ * channel passwords during the handshake, the `clientmove` channel password,
+ * and the `cpw` field of the file transfer commands. Sending the plain text
+ * instead makes the server reject correct passwords with error 781.
+ */
+export function prepareClientPassword(password: string): string {
+  if (password === "") return "";
+  return createHash("sha1").update(password).digest().toString("base64");
+}
+
+/**
+ * The version `clientinit` sends unless the `version` option says otherwise.
+ *
+ * A literal on purpose: `@honeybbq/teamspeak/versions` holds over a thousand
+ * constants, and the client must not load them. A test holds this equal to the
+ * table's `Windows_3_X_X_5680278000`.
+ */
+export const defaultClientVersion: ClientVersion = {
+  platform: "Windows",
+  version: "3.?.? [Build: 5680278000]",
+  sign: "DX5NIYLvfJEUjuIbCidnoeozxIDRRkpq3I9vVMBmE9L2qnekOoBzSenkzsg2lC9CMv8K5hkEzhr2TYUYSwUXCg==",
+};
+
+export function sendClientInit(client: ClientInternals): void {
+  const cmd = buildClientInitCommand(client);
+  client.handler.sendPacket(PacketType.Command, Buffer.from(cmd), 0);
+}
+
+function buildClientInitCommand(client: ClientInternals): string {
+  const pubKeyBase64 = client.crypt.identity.publicKey();
+  const initOptions = client.initOptions;
+  // HWID should match TS3 client UID format: base64(SHA1(publicKey()))
+  const hwid = createHash("sha1").update(pubKeyBase64).digest().toString("base64");
+
+  return buildCommandOrdered("clientinit", [
+    ["client_nickname", client.nickname],
+    ["client_version", initOptions.version.version],
+    ["client_platform", initOptions.version.platform],
+    ["client_input_hardware", "1"],
+    ["client_output_hardware", "1"],
+    ["client_default_channel", initOptions.defaultChannel],
+    ["client_default_channel_password", initOptions.defaultChannelPasswordHash],
+    ["client_server_password", initOptions.serverPasswordHash],
+    ["client_meta_data", ""],
+    ["client_version_sign", initOptions.version.sign],
+    ["client_key_offset", String(client.crypt.identity.offset)],
+    ["client_nickname_phonetic", ""],
+    ["client_default_token", ""],
+    ["hwid", hwid],
+  ]);
+}

package/src/client/helpers.ts

@@ -0,0 +1,10 @@
+/**
+ * Reports whether `actual` equals `expected` or equals `expected` followed by
+ * only digits — the pattern TeamSpeak uses when a nickname is already taken.
+ */
+export function isAutoNicknameMatch(expected: string, actual: string): boolean {
+  if (actual === expected) return true;
+  if (!actual.startsWith(expected)) return false;
+  const suffix = actual.slice(expected.length);
+  return /^\d+$/.test(suffix);
+}

package/src/client/hooks.ts

@@ -0,0 +1,30 @@
+/**
+ * Report an error from a trace hook the way a throwing event listener's is
+ * reported: rethrown on its own, as an uncaught exception.
+ */
+function reportHookError(error: unknown): void {
+  queueMicrotask(() => {
+    throw error;
+  });
+}
+
+/**
+ * Call a trace hook, if there is one, and never let it touch what called it:
+ * a throw, or the rejection of a promise it returns, is reported as a
+ * throwing listener's is. The info is built only when there is a hook.
+ */
+export function callHook<I>(
+  hook: ((info: I) => unknown) | undefined,
+  owner: object | undefined,
+  info: () => I,
+): void {
+  if (hook === undefined) return;
+  try {
+    const result = hook.call(owner, info());
+    if (result !== null && typeof result === "object" && "then" in result) {
+      Promise.resolve(result).then(undefined, reportHookError);
+    }
+  } catch (error) {
+    reportHookError(error);
+  }
+}