novaapp-sdk 1.4.0 → 1.4.2

package/dist/testing/index.js

@@ -0,0 +1,849 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/testing/index.ts
+var testing_exports = {};
+__export(testing_exports, {
+  EventSimulator: () => EventSimulator,
+  HarnessAssertionError: () => HarnessAssertionError,
+  MockClient: () => MockClient,
+  TestHarness: () => TestHarness,
+  asMockClient: () => asMockClient
+});
+module.exports = __toCommonJS(testing_exports);
+
+// src/testing/MockClient.ts
+var import_node_events = require("events");
+var import_node_crypto = require("crypto");
+function mockMsg(override = {}) {
+  return {
+    id: `mock-msg-${(0, import_node_crypto.randomUUID)()}`,
+    content: "",
+    channelId: "ch-mock",
+    author: { id: "bot-user-id", username: "testbot", displayName: "Test Bot", avatar: null, isBot: true },
+    attachments: [],
+    reactions: [],
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...override
+  };
+}
+function makeApiProxy(namespace, calls, overrides = {}) {
+  return new Proxy({}, {
+    get(_target, prop) {
+      if (prop in overrides) return overrides[prop];
+      return (...args) => {
+        const result = { id: `mock-${(0, import_node_crypto.randomUUID)()}`, ok: true };
+        calls.push({ api: namespace, method: prop, args, result, timestamp: /* @__PURE__ */ new Date() });
+        return Promise.resolve(result);
+      };
+    }
+  });
+}
+var MockClient = class extends import_node_events.EventEmitter {
+  constructor() {
+    super(...arguments);
+    /** All recorded API calls, in chronological order. */
+    this.calls = [];
+    /** Simulated bot application info.  Pre-set to a default test value. */
+    this.botUser = {
+      id: "bot-app-id",
+      name: "TestBot",
+      username: "testbot",
+      displayName: "Test Bot",
+      description: null,
+      avatar: null,
+      category: null,
+      isPublic: false,
+      isVerified: false,
+      callbackUrl: null,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      botUser: {
+        id: "bot-user-id",
+        username: "testbot",
+        displayName: "Test Bot",
+        avatar: null,
+        isBot: true
+      },
+      scopes: ["messages.read", "messages.write"]
+    };
+    // ── API namespaces ─────────────────────────────────────────────────────────
+    /** Mocked `client.messages` — same method names as the real MessagesAPI. */
+    this.messages = makeApiProxy("messages", this.calls, {
+      send: (channelId, options) => {
+        const opts = options;
+        const result = mockMsg({ channelId, ...opts });
+        this.calls.push({ api: "messages", method: "send", args: [channelId, options], result, timestamp: /* @__PURE__ */ new Date() });
+        return Promise.resolve(result);
+      },
+      fetch: (channelId, _opts) => {
+        const result = [];
+        this.calls.push({ api: "messages", method: "fetch", args: [channelId, _opts], result, timestamp: /* @__PURE__ */ new Date() });
+        return Promise.resolve(result);
+      }
+    });
+    /** Mocked `client.interactions` — records `respond()` calls. */
+    this.interactions = makeApiProxy("interactions", this.calls);
+    /** Mocked `client.members` */
+    this.members = makeApiProxy("members", this.calls);
+    /** Mocked `client.channels` */
+    this.channels = makeApiProxy("channels", this.calls);
+    /** Mocked `client.roles` */
+    this.roles = makeApiProxy("roles", this.calls);
+    /** Mocked `client.servers` */
+    this.servers = makeApiProxy("servers", this.calls);
+    /** Mocked `client.invites` */
+    this.invites = makeApiProxy("invites", this.calls);
+    // Everything else (webhooks, reactions, permissions, etc.)
+    this.webhooks = makeApiProxy("webhooks", this.calls);
+    this.reactions = makeApiProxy("reactions", this.calls);
+    this.permissions = makeApiProxy("permissions", this.calls);
+    this.auditlog = makeApiProxy("auditlog", this.calls);
+    this.forum = makeApiProxy("forum", this.calls);
+    this.events = makeApiProxy("events", this.calls);
+    this.categories = makeApiProxy("categories", this.calls);
+    this.automod = makeApiProxy("automod", this.calls);
+    this.users = makeApiProxy("users", this.calls);
+    // ── Client methods ─────────────────────────────────────────────────────────
+    /**
+     * Recorded WS sends (via `client.wsSend`).
+     * Inspected by `harness.assert.wsSent()`.
+     */
+    this.wsSends = [];
+  }
+  wsSend(channelId, content) {
+    this.wsSends.push({ channelId, content });
+    this.calls.push({
+      api: "ws",
+      method: "wsSend",
+      args: [channelId, content],
+      result: void 0,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+  }
+  wsTypingStart(channelId) {
+    this.calls.push({ api: "ws", method: "wsTypingStart", args: [channelId], result: void 0, timestamp: /* @__PURE__ */ new Date() });
+  }
+  wsTypingStop(channelId) {
+    this.calls.push({ api: "ws", method: "wsTypingStop", args: [channelId], result: void 0, timestamp: /* @__PURE__ */ new Date() });
+  }
+  setStatus(_status) {
+  }
+  /** Simulated `client.connect()` — no-op in tests. */
+  connect() {
+    this.emit("ready", this.botUser);
+    return Promise.resolve(this);
+  }
+  /** Simulated `client.disconnect()` — emits `disconnect`. */
+  disconnect() {
+    this.emit("disconnect", "manual");
+  }
+  // ── Call inspection helpers ────────────────────────────────────────────────
+  /**
+   * Find all recorded calls to a given API namespace + method.
+   *
+   * @example
+   * ```ts
+   * const sends = client.findCalls('messages', 'send')
+   * // sends[0].args → [channelId, options]
+   * ```
+   */
+  findCalls(api, method) {
+    return this.calls.filter((c) => c.api === api && c.method === method);
+  }
+  /**
+   * Find all `messages.send` calls targeting a specific channel.
+   */
+  sentTo(channelId) {
+    return this.findCalls("messages", "send").filter((c) => c.args[0] === channelId);
+  }
+  /**
+   * Find all `interactions.respond` calls for a specific interaction ID.
+   */
+  repliedTo(interactionId) {
+    return this.findCalls("interactions", "respond").filter((c) => c.args[0] === interactionId);
+  }
+  /** Reset all recorded calls and WS sends. */
+  resetCalls() {
+    this.calls.length = 0;
+    this.wsSends.length = 0;
+  }
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  once(event, listener) {
+    return super.once(event, listener);
+  }
+  off(event, listener) {
+    return super.off(event, listener);
+  }
+  emit(event, ...args) {
+    return super.emit(event, ...args);
+  }
+};
+function asMockClient(client) {
+  return client;
+}
+
+// src/testing/EventSimulator.ts
+var import_node_crypto2 = require("crypto");
+
+// src/testing/types.ts
+function buildMockMessage(input = {}) {
+  return {
+    id: input.id ?? `msg-${Date.now()}`,
+    content: input.content ?? "",
+    channelId: input.channelId ?? "ch-default",
+    author: {
+      id: input.authorId ?? "user-default",
+      username: input.authorName ?? "user",
+      displayName: input.authorName ?? "User",
+      avatar: null,
+      isBot: false
+    },
+    attachments: [],
+    reactions: [],
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...input.extra
+  };
+}
+function buildMockInteraction(input = {}) {
+  return {
+    id: `int-${Date.now()}`,
+    type: input.type ?? "SLASH_COMMAND",
+    commandName: input.commandName ?? null,
+    customId: input.customId ?? null,
+    data: input.data ?? null,
+    values: input.values,
+    modalData: input.modalData,
+    userId: input.userId ?? "user-default",
+    channelId: input.channelId ?? "ch-default",
+    serverId: input.serverId ?? "srv-default",
+    triggerMsgId: null,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...input.extra
+  };
+}
+function buildMockMember(input = {}) {
+  return {
+    role: input.role ?? "MEMBER",
+    joinedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    user: {
+      id: input.userId ?? "user-default",
+      username: "user",
+      displayName: "User",
+      avatar: null,
+      status: "ONLINE",
+      isBot: false
+    },
+    ...input.extra
+  };
+}
+
+// src/testing/EventSimulator.ts
+var EventSimulator = class {
+  constructor(client) {
+    this.client = client;
+  }
+  // ── Helpers ────────────────────────────────────────────────────────────────
+  /** Await all already-queued microtasks (useful after async event handlers). */
+  flush() {
+    return new Promise((resolve) => setImmediate(resolve));
+  }
+  // ── Message events ─────────────────────────────────────────────────────────
+  /**
+   * Emit a `message` event (bot received a message in a text channel).
+   *
+   * @example
+   * ```ts
+   * sim.message({ content: '!ping', channelId: 'ch-1' })
+   * ```
+   */
+  message(input = {}) {
+    const msg = buildMockMessage(input);
+    this.client.emit("message", msg);
+    return msg;
+  }
+  /**
+   * Emit a `messageEdit` event.
+   */
+  messageEdit(input = {}) {
+    const msg = buildMockMessage({ ...input, content: input.newContent ?? input.content });
+    this.client.emit("messageEdit", msg);
+    return msg;
+  }
+  /**
+   * Emit a `messageDelete` event.
+   */
+  messageDelete(messageId, channelId) {
+    const payload = { messageId: messageId ?? `msg-${(0, import_node_crypto2.randomUUID)()}`, channelId: channelId ?? "ch-default" };
+    this.client.emit("messageDelete", payload);
+    return payload;
+  }
+  // ── Interaction events ─────────────────────────────────────────────────────
+  /**
+   * Emit an `interaction` event for any interaction type.
+   *
+   * @example
+   * ```ts
+   * sim.interaction({ type: 'PREFIX_COMMAND', commandName: 'help' })
+   * ```
+   */
+  interaction(input = {}) {
+    const interaction = buildMockInteraction(input);
+    this.client.emit("interaction", interaction);
+    return interaction;
+  }
+  /**
+   * Fire a `SLASH_COMMAND` interaction.
+   *
+   * @example
+   * ```ts
+   * sim.slashCommand({ name: 'ping' })
+   * sim.slashCommand({ name: 'ban', options: { user: 'user-123', reason: 'spam' } })
+   * ```
+   */
+  slashCommand(input) {
+    return this.interaction({
+      type: "SLASH_COMMAND",
+      commandName: input.name,
+      userId: input.userId,
+      channelId: input.channelId,
+      serverId: input.serverId,
+      data: input.options
+    });
+  }
+  /**
+   * Fire a `BUTTON_CLICK` interaction.
+   *
+   * @example
+   * ```ts
+   * sim.buttonClick({ customId: 'confirm_delete' })
+   * ```
+   */
+  buttonClick(input) {
+    return this.interaction({
+      type: "BUTTON_CLICK",
+      customId: input.customId,
+      userId: input.userId,
+      channelId: input.channelId,
+      serverId: input.serverId,
+      extra: { triggerMsgId: input.triggerMsgId ?? null }
+    });
+  }
+  /**
+   * Fire a `SELECT_MENU` interaction.
+   *
+   * @example
+   * ```ts
+   * sim.selectMenu({ customId: 'role_picker', values: ['mod', 'admin'] })
+   * ```
+   */
+  selectMenu(input) {
+    return this.interaction({
+      type: "SELECT_MENU",
+      customId: input.customId,
+      values: input.values,
+      userId: input.userId,
+      channelId: input.channelId,
+      serverId: input.serverId
+    });
+  }
+  /**
+   * Fire a `MODAL_SUBMIT` interaction.
+   *
+   * @example
+   * ```ts
+   * sim.modalSubmit({ customId: 'report_modal', modalData: { reason: 'spam' } })
+   * ```
+   */
+  modalSubmit(input) {
+    return this.interaction({
+      type: "MODAL_SUBMIT",
+      customId: input.customId,
+      modalData: input.modalData,
+      userId: input.userId,
+      channelId: input.channelId,
+      serverId: input.serverId
+    });
+  }
+  /**
+   * Fire a `PREFIX_COMMAND` interaction.
+   *
+   * @example
+   * ```ts
+   * sim.prefixCommand({ name: 'kick', userId: 'user-1' })
+   * ```
+   */
+  prefixCommand(input) {
+    return this.interaction({
+      type: "PREFIX_COMMAND",
+      commandName: input.name,
+      userId: input.userId,
+      channelId: input.channelId,
+      serverId: input.serverId,
+      data: input.options
+    });
+  }
+  // ── Member events ──────────────────────────────────────────────────────────
+  /**
+   * Emit a `memberJoin` event.
+   *
+   * @example
+   * ```ts
+   * sim.memberJoin({ userId: 'user-123', serverId: 'srv-1' })
+   * ```
+   */
+  memberJoin(input = {}) {
+    const member = buildMockMember(input);
+    this.client.emit("memberJoin", member, input.serverId ?? "srv-default");
+    return member;
+  }
+  /**
+   * Emit a `memberLeave` event.
+   */
+  memberLeave(input = {}) {
+    const member = buildMockMember(input);
+    this.client.emit("memberLeave", member, input.serverId ?? "srv-default");
+    return member;
+  }
+  /**
+   * Emit a `memberUpdate` event.
+   */
+  memberUpdate(serverId, userId) {
+    this.client.emit("memberUpdate", {
+      userId: userId ?? "user-default",
+      serverId: serverId ?? "srv-default"
+    });
+  }
+  // ── Voice events ───────────────────────────────────────────────────────────
+  /**
+   * Emit a `voiceJoin` event.
+   *
+   * @example
+   * ```ts
+   * sim.voiceJoin({ userId: 'user-1', channelId: 'vc-1', serverId: 'srv-1' })
+   * ```
+   */
+  voiceJoin(input = {}) {
+    const payload = {
+      userId: input.userId ?? "user-default",
+      channelId: input.channelId ?? "vc-default",
+      serverId: input.serverId ?? "srv-default"
+    };
+    this.client.emit("voiceJoin", payload);
+    return payload;
+  }
+  /**
+   * Emit a `voiceLeave` event.
+   */
+  voiceLeave(input = {}) {
+    const payload = {
+      userId: input.userId ?? "user-default",
+      channelId: input.channelId ?? "vc-default",
+      serverId: input.serverId ?? "srv-default"
+    };
+    this.client.emit("voiceLeave", payload);
+    return payload;
+  }
+  // ── Reaction events ────────────────────────────────────────────────────────
+  /**
+   * Emit a `reactionAdd` event.
+   *
+   * @example
+   * ```ts
+   * sim.reactionAdd({ messageId: 'msg-1', emoji: '👍' })
+   * ```
+   */
+  reactionAdd(input) {
+    this.client.emit("reactionAdd", {
+      messageId: input.messageId,
+      emoji: input.emoji,
+      userId: input.userId ?? "user-default",
+      channelId: input.channelId ?? "ch-default"
+    });
+  }
+  /**
+   * Emit a `reactionRemove` event.
+   */
+  reactionRemove(input) {
+    this.client.emit("reactionRemove", {
+      messageId: input.messageId,
+      emoji: input.emoji,
+      userId: input.userId ?? "user-default",
+      channelId: input.channelId ?? "ch-default"
+    });
+  }
+  // ── Channel / role / server events ─────────────────────────────────────────
+  /**
+   * Emit a `channelCreate` event.
+   */
+  channelCreate(partial) {
+    const ch = {
+      id: `ch-${(0, import_node_crypto2.randomUUID)()}`,
+      name: "test-channel",
+      type: "TEXT",
+      topic: null,
+      position: 0,
+      slowMode: 0,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...partial
+    };
+    this.client.emit("channelCreate", ch);
+    return ch;
+  }
+  /**
+   * Emit a `channelDelete` event.
+   */
+  channelDelete(id, serverId) {
+    this.client.emit("channelDelete", { id, serverId });
+  }
+  /**
+   * Emit a `roleCreate` event.
+   */
+  roleCreate(partial) {
+    const role = {
+      id: `role-${(0, import_node_crypto2.randomUUID)()}`,
+      name: "test-role",
+      color: null,
+      position: 0,
+      hoist: false,
+      permissions: {},
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...partial
+    };
+    this.client.emit("roleCreate", role);
+    return role;
+  }
+  /**
+   * Emit a `roleDelete` event.
+   */
+  roleDelete(id, serverId) {
+    this.client.emit("roleDelete", { id, serverId });
+  }
+  // ── Moderation events ──────────────────────────────────────────────────────
+  /**
+   * Emit a `memberBanned` event.
+   */
+  memberBanned(userId, serverId, reason) {
+    this.client.emit("memberBanned", {
+      userId,
+      serverId,
+      moderatorId: this.client.botUser?.botUser?.id ?? null,
+      reason: reason ?? null
+    });
+  }
+  /**
+   * Emit a `memberUnbanned` event.
+   */
+  memberUnbanned(userId, serverId) {
+    this.client.emit("memberUnbanned", { userId, serverId });
+  }
+  // ── Bot lifecycle events ───────────────────────────────────────────────────
+  /**
+   * Emit the `ready` event (simulates successful bot connection).
+   */
+  ready() {
+    this.client.emit("ready", this.client.botUser);
+  }
+  /**
+   * Emit the `disconnect` event.
+   */
+  disconnect(reason = "test") {
+    this.client.emit("disconnect", reason);
+  }
+};
+
+// src/testing/TestHarness.ts
+var HarnessAssertions = class {
+  constructor(client) {
+    this.client = client;
+  }
+  // ── Send assertions ──────────────────────────────────────────────────────
+  /**
+   * Assert that `messages.send` was called **at least once** (or exactly `times`
+   * times), optionally matching specific call properties.
+   */
+  sent(options = {}) {
+    const raw = this.client.findCalls("messages", "send");
+    const { content, channelId, embedTitle, embedField, times } = options;
+    const matches = raw.filter((call) => {
+      const [cid, opts] = call.args;
+      if (channelId && cid !== channelId) return false;
+      if (content) {
+        const bodyContent = opts?.content ?? "";
+        if (!bodyContent.includes(content)) return false;
+      }
+      if (embedTitle) {
+        const embeds = opts?.embeds ?? [];
+        if (!embeds.some((e) => e.title?.includes(embedTitle))) return false;
+      }
+      if (embedField) {
+        const embeds = opts?.embeds ?? [];
+        const hasField = embeds.some(
+          (e) => e.fields?.some(
+            (f) => f.name?.includes(embedField) || f.value?.includes(embedField)
+          )
+        );
+        if (!hasField) return false;
+      }
+      return true;
+    });
+    if (times !== void 0) {
+      if (matches.length !== times) {
+        throw new HarnessAssertionError(
+          `Expected messages.send to be called ${times} time(s) matching options, but got ${matches.length}.` + formatCallDiff(raw, options)
+        );
+      }
+    } else if (matches.length === 0) {
+      throw new HarnessAssertionError(
+        `Expected messages.send to be called${describeOptions(options)}, but no matching calls were found.` + formatCallDiff(raw, options)
+      );
+    }
+  }
+  /**
+   * Assert that `interactions.respond` was called, optionally matching content.
+   */
+  replied(options = {}) {
+    const raw = this.client.findCalls("interactions", "respond");
+    const { content, embedTitle, times } = options;
+    const matches = raw.filter((call) => {
+      const [, opts] = call.args;
+      if (content) {
+        const bodyContent = opts?.content ?? "";
+        if (!bodyContent.includes(content)) return false;
+      }
+      if (embedTitle) {
+        const embeds = opts?.embeds ?? [];
+        if (!embeds.some((e) => e.title?.includes(embedTitle))) return false;
+      }
+      return true;
+    });
+    if (times !== void 0) {
+      if (matches.length !== times) {
+        throw new HarnessAssertionError(
+          `Expected interactions.respond to be called ${times} time(s), but got ${matches.length}.`
+        );
+      }
+    } else if (matches.length === 0) {
+      throw new HarnessAssertionError(
+        `Expected interactions.respond to be called${describeOptions(options)}, but no matching calls were found.`
+      );
+    }
+  }
+  /**
+   * Assert that `client.wsSend` was called (optionally matching channel/content).
+   */
+  wsSent(channelId, content) {
+    const matches = this.client.wsSends.filter((send) => {
+      if (channelId && send.channelId !== channelId) return false;
+      if (content && !send.content.includes(content)) return false;
+      return true;
+    });
+    if (matches.length === 0) {
+      throw new HarnessAssertionError(
+        `Expected wsSend to be called${channelId ? ` to channel "${channelId}"` : ""}${content ? ` with content "${content}"` : ""}, but no matching sends found.`
+      );
+    }
+  }
+  /**
+   * Assert that a specific API method was called exactly `expected` times.
+   *
+   * @example
+   * ```ts
+   * harness.assert.callCount('members', 'kick', 1)
+   * ```
+   */
+  callCount(api, method, expected) {
+    const actual = this.client.findCalls(api, method).length;
+    if (actual !== expected) {
+      throw new HarnessAssertionError(
+        `Expected ${api}.${method} to be called ${expected} time(s), but was called ${actual} time(s).`
+      );
+    }
+  }
+  /**
+   * Assert that no API calls have been recorded.
+   */
+  noCalls() {
+    if (this.client.calls.length > 0) {
+      const summary = this.client.calls.map((c) => `  ${c.api}.${c.method}`).join("\n");
+      throw new HarnessAssertionError(
+        `Expected no API calls, but found ${this.client.calls.length}:
+${summary}`
+      );
+    }
+  }
+  /**
+   * Assert that no messages were sent (neither via `messages.send` nor `wsSend`).
+   */
+  noMessagesSent() {
+    const sends = this.client.findCalls("messages", "send");
+    const wsSends = this.client.wsSends;
+    if (sends.length > 0 || wsSends.length > 0) {
+      throw new HarnessAssertionError(
+        `Expected no messages to be sent, but found ${sends.length} message.send call(s) and ${wsSends.length} wsSend call(s).`
+      );
+    }
+  }
+  /**
+   * Assert that a specific API method was called at least once.
+   *
+   * @example
+   * ```ts
+   * harness.assert.called('members', 'kick')
+   * ```
+   */
+  called(api, method) {
+    const found = this.client.findCalls(api, method);
+    if (found.length === 0) {
+      throw new HarnessAssertionError(`Expected ${api}.${method} to be called, but it was not.`);
+    }
+  }
+  /**
+   * Assert that a specific API method was **never** called.
+   *
+   * @example
+   * ```ts
+   * harness.assert.notCalled('members', 'ban')
+   * ```
+   */
+  notCalled(api, method) {
+    const found = this.client.findCalls(api, method);
+    if (found.length > 0) {
+      throw new HarnessAssertionError(
+        `Expected ${api}.${method} not to be called, but it was called ${found.length} time(s).`
+      );
+    }
+  }
+};
+var TestHarness = class {
+  constructor() {
+    this.client = new MockClient();
+    this.simulate = new EventSimulator(this.client);
+    this.assert = new HarnessAssertions(this.client);
+  }
+  // ── Setup ──────────────────────────────────────────────────────────────────
+  /**
+   * Run a setup function against the mock client (e.g. register commands /
+   * event handlers). Supports both sync and async setups.
+   *
+   * Chainable — call `use` multiple times to compose setup:
+   *
+   * @example
+   * ```ts
+   * harness
+   *   .use(registerCommands)
+   *   .use(registerEventHandlers)
+   * ```
+   */
+  use(fn) {
+    const result = fn(this.client);
+    if (result instanceof Promise) {
+      result.catch((err) => {
+        throw err;
+      });
+    }
+    return this;
+  }
+  // ── State management ───────────────────────────────────────────────────────
+  /**
+   * Clear all recorded API calls, wsSend history, and event listeners.
+   * Returns `this` so you can chain: `harness.reset().use(...)`.
+   */
+  reset() {
+    this.client.resetCalls();
+    this.client.removeAllListeners();
+    return this;
+  }
+  /**
+   * Awaits all queued microtasks and setImmediate callbacks so that any async
+   * event handlers registered with `use()` have fully run.
+   *
+   * @example
+   * ```ts
+   * harness.simulate.slashCommand({ name: 'ban', options: { user: 'u-1' } })
+   * await harness.flush()
+   * harness.assert.called('members', 'ban')
+   * ```
+   */
+  flush() {
+    return new Promise((resolve) => setImmediate(resolve));
+  }
+  // ── Direct call access ─────────────────────────────────────────────────────
+  /**
+   * All recorded API calls (shorthand for `harness.client.calls`).
+   */
+  get calls() {
+    return this.client.calls;
+  }
+  /**
+   * All `messages.send` calls targeting `channelId` (or all if omitted).
+   */
+  getSent(channelId) {
+    const raw = this.client.findCalls("messages", "send");
+    return raw.filter((c) => {
+      const [cid] = c.args;
+      return channelId === void 0 || cid === channelId;
+    }).map((c) => {
+      const [cid, ...rest] = c.args;
+      return { channelId: cid, args: rest };
+    });
+  }
+  /**
+   * All `interactions.respond` call payloads.
+   */
+  getReplies() {
+    return this.client.findCalls("interactions", "respond").map((c) => {
+      const [iid, ...rest] = c.args;
+      return { interactionId: iid, args: rest };
+    });
+  }
+};
+var HarnessAssertionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "HarnessAssertionError";
+  }
+};
+function describeOptions(options) {
+  const parts = [];
+  if ("channelId" in options && options.channelId) parts.push(`to channel "${options.channelId}"`);
+  if (options.content) parts.push(`containing "${options.content}"`);
+  if (options.embedTitle) parts.push(`with embed title "${options.embedTitle}"`);
+  return parts.length ? ` ${parts.join(", ")}` : "";
+}
+function formatCallDiff(calls, options) {
+  if (calls.length === 0) return "\n  (no messages.send calls recorded)";
+  const list = calls.map((c) => {
+    const [cid, opts] = c.args;
+    const content = opts?.content ?? "(none)";
+    return `  \u2192 channelId=${cid}  content="${content.slice(0, 60)}"`;
+  }).join("\n");
+  return `
+  Recorded calls:
+${list}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EventSimulator,
+  HarnessAssertionError,
+  MockClient,
+  TestHarness,
+  asMockClient
+});