shardwire 1.1.0 → 1.3.0

package/dist/index.js

@@ -36,8 +36,14 @@ var BOT_EVENT_NAMES = [
   "messageDelete",
   "messageReactionAdd",
   "messageReactionRemove",
+  "guildCreate",
+  "guildDelete",
   "guildMemberAdd",
-  "guildMemberRemove"
+  "guildMemberRemove",
+  "guildMemberUpdate",
+  "threadCreate",
+  "threadUpdate",
+  "threadDelete"
 ];
 var BOT_ACTION_NAMES = [
   "sendMessage",
@@ -45,7 +51,14 @@ var BOT_ACTION_NAMES = [
   "deleteMessage",
   "replyToInteraction",
   "deferInteraction",
+  "deferUpdateInteraction",
   "followUpInteraction",
+  "editInteractionReply",
+  "deleteInteractionReply",
+  "updateInteraction",
+  "showModal",
+  "fetchMessage",
+  "fetchMember",
   "banMember",
   "kickMember",
   "addMemberRole",
@@ -67,12 +80,20 @@ var EVENT_REQUIRED_INTENTS = {
   messageDelete: ["GuildMessages"],
   messageReactionAdd: ["GuildMessageReactions"],
   messageReactionRemove: ["GuildMessageReactions"],
+  guildCreate: ["Guilds"],
+  guildDelete: ["Guilds"],
   guildMemberAdd: ["GuildMembers"],
-  guildMemberRemove: ["GuildMembers"]
+  guildMemberRemove: ["GuildMembers"],
+  guildMemberUpdate: ["GuildMembers"],
+  threadCreate: ["Guilds"],
+  threadUpdate: ["Guilds"],
+  threadDelete: ["Guilds"]
 };
 function getAvailableEvents(intents) {
   const enabled = new Set(intents);
-  return BOT_EVENT_NAMES.filter((eventName) => EVENT_REQUIRED_INTENTS[eventName].every((intent) => enabled.has(intent)));
+  return BOT_EVENT_NAMES.filter(
+    (eventName) => EVENT_REQUIRED_INTENTS[eventName].every((intent) => enabled.has(intent))
+  );
 }
 
 // src/discord/runtime/adapter.ts
@@ -158,6 +179,7 @@ function serializeMessage(message) {
     ...message.reference.channelId ? { channelId: message.reference.channelId } : {},
     ...message.reference.guildId ? { guildId: message.reference.guildId } : {}
   } : void 0;
+  const components = "components" in message && message.components && message.components.length > 0 ? message.components.map((row) => row.toJSON()) : void 0;
   return {
     id: message.id,
     channelId: message.channelId,
@@ -175,9 +197,29 @@ function serializeMessage(message) {
       size: attachment.size
     })) : [],
     embeds: serializeEmbeds(message),
+    ...components ? { components } : {},
     ...reference ? { reference } : {}
   };
 }
+function serializeGuild(guild) {
+  return {
+    id: guild.id,
+    name: guild.name,
+    ...guild.icon !== null && guild.icon !== void 0 ? { icon: guild.icon } : { icon: null },
+    ownerId: guild.ownerId
+  };
+}
+function serializeThread(thread) {
+  return {
+    id: thread.id,
+    guildId: thread.guildId,
+    parentId: thread.parentId,
+    name: thread.name,
+    type: thread.type,
+    ...typeof thread.archived === "boolean" ? { archived: thread.archived } : {},
+    ...typeof thread.locked === "boolean" ? { locked: thread.locked } : {}
+  };
+}
 function serializeDeletedMessage(message) {
   return {
     id: message.id,
@@ -347,7 +389,10 @@ function toSendOptions(input) {
   return {
     ...input.content !== void 0 ? { content: input.content } : {},
     ...input.embeds !== void 0 ? { embeds: input.embeds } : {},
-    ...input.allowedMentions !== void 0 ? { allowedMentions: input.allowedMentions } : {}
+    ...input.allowedMentions !== void 0 ? { allowedMentions: input.allowedMentions } : {},
+    ...input.components !== void 0 ? { components: input.components } : {},
+    ...input.flags !== void 0 ? { flags: input.flags } : {},
+    ...input.stickerIds !== void 0 ? { stickers: input.stickerIds } : {}
   };
 }
 function extractDiscordErrorDetails(error) {
@@ -371,14 +416,34 @@ function extractDiscordErrorDetails(error) {
 function mapDiscordErrorToActionExecutionError(error) {
   const details = extractDiscordErrorDetails(error);
   const message = details.message ?? (error instanceof Error ? error.message : "Discord action failed.");
+  const detailPayload = {
+    ...typeof details.status === "number" ? { discordStatus: details.status } : {},
+    ...typeof details.code === "number" ? { discordCode: details.code } : {}
+  };
   if (details.status === 403 || details.code !== void 0 && DISCORD_FORBIDDEN_CODES.has(details.code)) {
-    return new ActionExecutionError("FORBIDDEN", message);
+    return new ActionExecutionError("FORBIDDEN", message, detailPayload);
   }
   if (details.status === 404 || details.code !== void 0 && DISCORD_NOT_FOUND_CODES.has(details.code)) {
-    return new ActionExecutionError("NOT_FOUND", message);
+    return new ActionExecutionError("NOT_FOUND", message, detailPayload);
   }
   if (details.status === 400 || details.code !== void 0 && DISCORD_INVALID_REQUEST_CODES.has(details.code)) {
-    return new ActionExecutionError("INVALID_REQUEST", message);
+    return new ActionExecutionError("INVALID_REQUEST", message, detailPayload);
+  }
+  if (details.status === 429) {
+    let retryAfterMs;
+    if (error instanceof import_discord2.DiscordAPIError) {
+      const raw = error.rawError;
+      const retryAfter = raw?.retry_after;
+      if (typeof retryAfter === "number" && Number.isFinite(retryAfter)) {
+        retryAfterMs = Math.max(0, Math.ceil(retryAfter * 1e3));
+      }
+    }
+    return new ActionExecutionError("SERVICE_UNAVAILABLE", message, {
+      discordStatus: 429,
+      retryable: true,
+      ...details.code !== void 0 ? { discordCode: details.code } : {},
+      ...retryAfterMs !== void 0 ? { retryAfterMs } : {}
+    });
   }
   return null;
 }
@@ -399,7 +464,14 @@ var DiscordJsRuntimeAdapter = class {
       deleteMessage: (payload) => this.deleteMessage(payload),
       replyToInteraction: (payload) => this.replyToInteraction(payload),
       deferInteraction: (payload) => this.deferInteraction(payload),
+      deferUpdateInteraction: (payload) => this.deferUpdateInteraction(payload),
       followUpInteraction: (payload) => this.followUpInteraction(payload),
+      editInteractionReply: (payload) => this.editInteractionReply(payload),
+      deleteInteractionReply: (payload) => this.deleteInteractionReply(payload),
+      updateInteraction: (payload) => this.updateInteraction(payload),
+      showModal: (payload) => this.showModal(payload),
+      fetchMessage: (payload) => this.fetchMessage(payload),
+      fetchMember: (payload) => this.fetchMember(payload),
       banMember: (payload) => this.banMember(payload),
       kickMember: (payload) => this.kickMember(payload),
       addMemberRole: (payload) => this.addMemberRole(payload),
@@ -415,6 +487,10 @@ var DiscordJsRuntimeAdapter = class {
   actionHandlers;
   readyPromise = null;
   hasReady = false;
+  shardEnvelope() {
+    const shardId = this.client.shard?.ids?.[0];
+    return shardId !== void 0 ? { shardId } : {};
+  }
   isReady() {
     return this.hasReady && this.client.isReady();
   }
@@ -463,6 +539,7 @@ var DiscordJsRuntimeAdapter = class {
           }
           handler({
             receivedAt: Date.now(),
+            ...this.shardEnvelope(),
             user: serializeUser(this.client.user)
           });
         };
@@ -476,11 +553,10 @@ var DiscordJsRuntimeAdapter = class {
       }
       case "interactionCreate": {
         const listener = (interaction) => {
-          if (isReplyCapableInteraction(interaction)) {
-            this.interactionCache.set(interaction.id, interaction);
-          }
+          this.interactionCache.set(interaction.id, interaction);
           handler({
             receivedAt: Date.now(),
+            ...this.shardEnvelope(),
             interaction: serializeInteraction(interaction)
           });
         };
@@ -493,6 +569,7 @@ var DiscordJsRuntimeAdapter = class {
         const listener = (message) => {
           handler({
             receivedAt: Date.now(),
+            ...this.shardEnvelope(),
             message: serializeMessage(message)
           });
         };
@@ -505,6 +582,7 @@ var DiscordJsRuntimeAdapter = class {
         const listener = (oldMessage, newMessage) => {
           handler({
             receivedAt: Date.now(),
+            ...this.shardEnvelope(),
             oldMessage: serializeMessage(oldMessage),
             message: serializeMessage(newMessage)
           });
@@ -518,6 +596,7 @@ var DiscordJsRuntimeAdapter = class {
         const listener = (message) => {
           handler({
             receivedAt: Date.now(),
+            ...this.shardEnvelope(),
             message: serializeDeletedMessage(message)
           });
         };
@@ -530,6 +609,7 @@ var DiscordJsRuntimeAdapter = class {
         const listener = (reaction, user) => {
           handler({
             receivedAt: Date.now(),
+            ...this.shardEnvelope(),
             reaction: serializeMessageReaction(reaction, user)
           });
         };
@@ -542,6 +622,7 @@ var DiscordJsRuntimeAdapter = class {
         const listener = (reaction, user) => {
           handler({
             receivedAt: Date.now(),
+            ...this.shardEnvelope(),
             reaction: serializeMessageReaction(reaction, user)
           });
         };
@@ -554,6 +635,7 @@ var DiscordJsRuntimeAdapter = class {
         const listener = (member) => {
           handler({
             receivedAt: Date.now(),
+            ...this.shardEnvelope(),
             member: serializeGuildMember(member)
           });
         };
@@ -566,6 +648,7 @@ var DiscordJsRuntimeAdapter = class {
         const listener = (member) => {
           handler({
             receivedAt: Date.now(),
+            ...this.shardEnvelope(),
             member: serializeGuildMember(member)
           });
         };
@@ -574,6 +657,91 @@ var DiscordJsRuntimeAdapter = class {
           this.client.off(import_discord2.Events.GuildMemberRemove, listener);
         };
       }
+      case "guildMemberUpdate": {
+        const listener = (oldMember, newMember) => {
+          handler({
+            receivedAt: Date.now(),
+            ...this.shardEnvelope(),
+            oldMember: serializeGuildMember(oldMember),
+            member: serializeGuildMember(newMember)
+          });
+        };
+        this.client.on(import_discord2.Events.GuildMemberUpdate, listener);
+        return () => {
+          this.client.off(import_discord2.Events.GuildMemberUpdate, listener);
+        };
+      }
+      case "guildCreate": {
+        const listener = (guild) => {
+          handler({
+            receivedAt: Date.now(),
+            ...this.shardEnvelope(),
+            guild: serializeGuild(guild)
+          });
+        };
+        this.client.on(import_discord2.Events.GuildCreate, listener);
+        return () => {
+          this.client.off(import_discord2.Events.GuildCreate, listener);
+        };
+      }
+      case "guildDelete": {
+        const listener = (guild) => {
+          handler({
+            receivedAt: Date.now(),
+            ...this.shardEnvelope(),
+            guild: {
+              id: guild.id,
+              name: guild.name ?? "Unknown",
+              icon: guild.icon,
+              ...guild.ownerId ? { ownerId: guild.ownerId } : {}
+            }
+          });
+        };
+        this.client.on(import_discord2.Events.GuildDelete, listener);
+        return () => {
+          this.client.off(import_discord2.Events.GuildDelete, listener);
+        };
+      }
+      case "threadCreate": {
+        const listener = (thread) => {
+          handler({
+            receivedAt: Date.now(),
+            ...this.shardEnvelope(),
+            thread: serializeThread(thread)
+          });
+        };
+        this.client.on(import_discord2.Events.ThreadCreate, listener);
+        return () => {
+          this.client.off(import_discord2.Events.ThreadCreate, listener);
+        };
+      }
+      case "threadUpdate": {
+        const listener = (oldThread, newThread) => {
+          handler({
+            receivedAt: Date.now(),
+            ...this.shardEnvelope(),
+            oldThread: serializeThread(oldThread),
+            thread: serializeThread(newThread)
+          });
+        };
+        this.client.on(import_discord2.Events.ThreadUpdate, listener);
+        return () => {
+          this.client.off(import_discord2.Events.ThreadUpdate, listener);
+        };
+      }
+      case "threadDelete": {
+        const listener = (thread) => {
+          handler({
+            receivedAt: Date.now(),
+            ...this.shardEnvelope(),
+            thread: serializeThread(thread)
+          });
+        };
+        this.client.on(import_discord2.Events.ThreadDelete, listener);
+        return () => {
+          this.client.off(import_discord2.Events.ThreadDelete, listener);
+        };
+      }
       default:
         return () => void 0;
     }
@@ -592,7 +760,10 @@ var DiscordJsRuntimeAdapter = class {
         throw mappedError;
       }
       this.logger.error("Discord action execution failed.", { action: name, error: String(error) });
-      throw new ActionExecutionError("INTERNAL_ERROR", error instanceof Error ? error.message : "Discord action failed.");
+      throw new ActionExecutionError(
+        "INTERNAL_ERROR",
+        error instanceof Error ? error.message : "Discord action failed."
+      );
     }
   }
   async fetchSendableChannel(channelId) {
@@ -616,6 +787,26 @@ var DiscordJsRuntimeAdapter = class {
     }
     return interaction;
   }
+  getReplyCapableInteraction(interactionId) {
+    const interaction = this.getInteraction(interactionId);
+    if (!isReplyCapableInteraction(interaction)) {
+      throw new ActionExecutionError(
+        "INVALID_REQUEST",
+        `Interaction "${interactionId}" does not support reply-style acknowledgements.`
+      );
+    }
+    return interaction;
+  }
+  getMessageComponentInteraction(interactionId) {
+    const interaction = this.getInteraction(interactionId);
+    if (!interaction.isMessageComponent()) {
+      throw new ActionExecutionError(
+        "INVALID_REQUEST",
+        `Interaction "${interactionId}" is not a message component interaction.`
+      );
+    }
+    return interaction;
+  }
   async sendMessage(payload) {
     const channel = await this.fetchSendableChannel(payload.channelId);
     const message = await channel.send(toSendOptions(payload));
@@ -638,9 +829,12 @@ var DiscordJsRuntimeAdapter = class {
     };
   }
   async replyToInteraction(payload) {
-    const interaction = this.getInteraction(payload.interactionId);
+    const interaction = this.getReplyCapableInteraction(payload.interactionId);
     if (interaction.replied || interaction.deferred) {
-      throw new ActionExecutionError("INVALID_REQUEST", `Interaction "${payload.interactionId}" has already been acknowledged.`);
+      throw new ActionExecutionError(
+        "INVALID_REQUEST",
+        `Interaction "${payload.interactionId}" has already been acknowledged.`
+      );
     }
     const reply = await interaction.reply({
       ...toSendOptions(payload),
@@ -650,9 +844,12 @@ var DiscordJsRuntimeAdapter = class {
     return serializeMessage(reply);
   }
   async deferInteraction(payload) {
-    const interaction = this.getInteraction(payload.interactionId);
+    const interaction = this.getReplyCapableInteraction(payload.interactionId);
     if (interaction.replied) {
-      throw new ActionExecutionError("INVALID_REQUEST", `Interaction "${payload.interactionId}" has already been replied to.`);
+      throw new ActionExecutionError(
+        "INVALID_REQUEST",
+        `Interaction "${payload.interactionId}" has already been replied to.`
+      );
     }
     if (!interaction.deferred) {
       await interaction.deferReply({
@@ -664,10 +861,21 @@ var DiscordJsRuntimeAdapter = class {
       interactionId: payload.interactionId
     };
   }
+  async deferUpdateInteraction(payload) {
+    const interaction = this.getMessageComponentInteraction(payload.interactionId);
+    await interaction.deferUpdate();
+    return {
+      deferred: true,
+      interactionId: payload.interactionId
+    };
+  }
   async followUpInteraction(payload) {
-    const interaction = this.getInteraction(payload.interactionId);
+    const interaction = this.getReplyCapableInteraction(payload.interactionId);
     if (!interaction.replied && !interaction.deferred) {
-      throw new ActionExecutionError("INVALID_REQUEST", `Interaction "${payload.interactionId}" has not been acknowledged yet.`);
+      throw new ActionExecutionError(
+        "INVALID_REQUEST",
+        `Interaction "${payload.interactionId}" has not been acknowledged yet.`
+      );
     }
     const followUp = await interaction.followUp({
       ...toSendOptions(payload),
@@ -675,6 +883,52 @@ var DiscordJsRuntimeAdapter = class {
     });
     return serializeMessage(followUp);
   }
+  async editInteractionReply(payload) {
+    const interaction = this.getReplyCapableInteraction(payload.interactionId);
+    const updated = await interaction.editReply({
+      ...toSendOptions(payload),
+      fetchReply: true
+    });
+    return serializeMessage(updated);
+  }
+  async deleteInteractionReply(payload) {
+    const interaction = this.getReplyCapableInteraction(payload.interactionId);
+    await interaction.deleteReply();
+    return {
+      deleted: true,
+      interactionId: payload.interactionId
+    };
+  }
+  async updateInteraction(payload) {
+    const interaction = this.getMessageComponentInteraction(payload.interactionId);
+    const updated = await interaction.update({
+      ...toSendOptions(payload),
+      fetchReply: true
+    });
+    return serializeMessage(updated);
+  }
+  async showModal(payload) {
+    const interaction = this.getMessageComponentInteraction(payload.interactionId);
+    await interaction.showModal({
+      title: payload.title,
+      customId: payload.customId,
+      components: payload.components
+    });
+    return {
+      shown: true,
+      interactionId: payload.interactionId
+    };
+  }
+  async fetchMessage(payload) {
+    const channel = await this.fetchMessageChannel(payload.channelId);
+    const message = await channel.messages.fetch(payload.messageId);
+    return serializeMessage(message);
+  }
+  async fetchMember(payload) {
+    const guild = await this.client.guilds.fetch(payload.guildId);
+    const member = await guild.members.fetch(payload.userId);
+    return serializeGuildMember(member);
+  }
   async banMember(payload) {
     const guild = await this.client.guilds.fetch(payload.guildId);
     await guild.members.ban(payload.userId, {
@@ -730,7 +984,10 @@ var DiscordJsRuntimeAdapter = class {
       return candidate.emoji.identifier === payload.emoji || candidate.emoji.name === payload.emoji || candidate.emoji.toString() === payload.emoji;
     });
     if (!reaction) {
-      throw new ActionExecutionError("NOT_FOUND", `Reaction "${payload.emoji}" was not found on message "${payload.messageId}".`);
+      throw new ActionExecutionError(
+        "NOT_FOUND",
+        `Reaction "${payload.emoji}" was not found on message "${payload.messageId}".`
+      );
     }
     await reaction.users.remove(ownUserId);
     return {
@@ -744,7 +1001,7 @@ function createDiscordJsRuntimeAdapter(options) {
   return new DiscordJsRuntimeAdapter(options);
 }
 function isReplyCapableInteraction(interaction) {
-  return interaction.isRepliable() && typeof interaction.reply === "function" && typeof interaction.deferReply === "function" && typeof interaction.followUp === "function";
+  return interaction.isRepliable() && typeof interaction.reply === "function" && typeof interaction.deferReply === "function" && typeof interaction.followUp === "function" && typeof interaction.editReply === "function" && typeof interaction.deleteReply === "function";
 }
 
 // src/bridge/transport/server.ts
@@ -768,6 +1025,16 @@ function normalizeStringList(value) {
   const normalized = [...new Set(rawValues.filter((entry) => typeof entry === "string" && entry.length > 0))].sort();
   return normalized.length > 0 ? normalized : void 0;
 }
+function normalizeKindList(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const rawValues = Array.isArray(value) ? value : [value];
+  const normalized = [
+    ...new Set(rawValues.filter((entry) => typeof entry === "string"))
+  ].sort();
+  return normalized.length > 0 ? normalized : void 0;
+}
 function normalizeEventSubscriptionFilter(filter) {
   if (!filter) {
     return void 0;
@@ -777,6 +1044,8 @@ function normalizeEventSubscriptionFilter(filter) {
   const channelIds = normalizeStringList(filter.channelId);
   const userIds = normalizeStringList(filter.userId);
   const commandNames = normalizeStringList(filter.commandName);
+  const customIds = normalizeStringList(filter.customId);
+  const interactionKinds = normalizeKindList(filter.interactionKind);
   if (guildIds) {
     normalized.guildId = guildIds;
   }
@@ -789,6 +1058,12 @@ function normalizeEventSubscriptionFilter(filter) {
   if (commandNames) {
     normalized.commandName = commandNames;
   }
+  if (customIds) {
+    normalized.customId = customIds;
+  }
+  if (interactionKinds) {
+    normalized.interactionKind = interactionKinds;
+  }
   return Object.keys(normalized).length > 0 ? normalized : void 0;
 }
 function normalizeEventSubscription(subscription) {
@@ -810,17 +1085,29 @@ function matchesField(value, allowed) {
   }
   return allowed.includes(value);
 }
+function matchesKind(value, allowed) {
+  if (!allowed) {
+    return true;
+  }
+  if (!value) {
+    return false;
+  }
+  return allowed.includes(value);
+}
 function eventMetadata(name, payload) {
   switch (name) {
     case "ready":
       return {};
     case "interactionCreate": {
       const interactionPayload = payload;
+      const ix = interactionPayload.interaction;
       return {
-        ...interactionPayload.interaction.guildId ? { guildId: interactionPayload.interaction.guildId } : {},
-        ...interactionPayload.interaction.channelId ? { channelId: interactionPayload.interaction.channelId } : {},
-        userId: interactionPayload.interaction.user.id,
-        ...interactionPayload.interaction.commandName ? { commandName: interactionPayload.interaction.commandName } : {}
+        ...ix.guildId ? { guildId: ix.guildId } : {},
+        ...ix.channelId ? { channelId: ix.channelId } : {},
+        userId: ix.user.id,
+        ...ix.commandName ? { commandName: ix.commandName } : {},
+        ...ix.customId ? { customId: ix.customId } : {},
+        interactionKind: ix.kind
       };
     }
     case "messageCreate": {
@@ -876,6 +1163,29 @@ function eventMetadata(name, payload) {
         userId: memberPayload.member.id
       };
     }
+    case "guildMemberUpdate": {
+      const memberPayload = payload;
+      return {
+        guildId: memberPayload.member.guildId,
+        userId: memberPayload.member.id
+      };
+    }
+    case "guildCreate":
+    case "guildDelete": {
+      const guildPayload = payload;
+      return {
+        guildId: guildPayload.guild.id
+      };
+    }
+    case "threadCreate":
+    case "threadUpdate":
+    case "threadDelete": {
+      const threadPayload = payload;
+      return {
+        guildId: threadPayload.thread.guildId,
+        ...threadPayload.thread.parentId ? { channelId: threadPayload.thread.parentId } : { channelId: threadPayload.thread.id }
+      };
+    }
     default:
       return {};
   }
@@ -886,7 +1196,7 @@ function matchesEventSubscription(subscription, payload) {
     return true;
   }
   const metadata = eventMetadata(normalized.name, payload);
-  return matchesField(metadata.guildId, normalized.filter.guildId) && matchesField(metadata.channelId, normalized.filter.channelId) && matchesField(metadata.userId, normalized.filter.userId) && matchesField(metadata.commandName, normalized.filter.commandName);
+  return matchesField(metadata.guildId, normalized.filter.guildId) && matchesField(metadata.channelId, normalized.filter.channelId) && matchesField(metadata.userId, normalized.filter.userId) && matchesField(metadata.commandName, normalized.filter.commandName) && matchesField(metadata.customId, normalized.filter.customId) && matchesKind(metadata.interactionKind, normalized.filter.interactionKind);
 }
 
 // src/bridge/transport/security.ts
@@ -922,22 +1232,81 @@ function stringifyEnvelope(envelope) {
   return JSON.stringify(envelope);
 }
 
+// src/utils/semaphore.ts
+var AsyncSemaphore = class {
+  constructor(max, acquireTimeoutMs) {
+    this.max = max;
+    this.acquireTimeoutMs = acquireTimeoutMs;
+  }
+  max;
+  acquireTimeoutMs;
+  active = 0;
+  waiters = [];
+  async run(fn) {
+    const release = await this.acquire();
+    try {
+      return await fn();
+    } finally {
+      release();
+    }
+  }
+  acquire() {
+    if (this.active < this.max) {
+      this.active += 1;
+      return Promise.resolve(() => this.release());
+    }
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        const index = this.waiters.findIndex((entry) => entry.timeout === timeout);
+        if (index >= 0) {
+          this.waiters.splice(index, 1);
+        }
+        reject(new Error("ACTION_QUEUE_TIMEOUT"));
+      }, this.acquireTimeoutMs);
+      this.waiters.push({
+        resolve: (release) => {
+          clearTimeout(timeout);
+          resolve(release);
+        },
+        reject,
+        timeout
+      });
+    });
+  }
+  release() {
+    this.active -= 1;
+    const next = this.waiters.shift();
+    if (next) {
+      clearTimeout(next.timeout);
+      this.active += 1;
+      next.resolve(() => this.release());
+    }
+  }
+};
+
 // src/bridge/transport/server.ts
 var CLOSE_AUTH_REQUIRED = 4001;
 var CLOSE_AUTH_FAILED = 4003;
 var CLOSE_INVALID_PAYLOAD = 4004;
+var CLOSE_SERVER_FULL = 4029;
+var CLOSE_AUTH_RATE_LIMITED = 4031;
 var BridgeTransportServer = class {
   constructor(config) {
     this.config = config;
     this.logger = withLogger(config.logger);
     this.heartbeatMs = config.options.server.heartbeatMs ?? 3e4;
+    const maxConcurrent = config.options.server.maxConcurrentActions ?? 32;
+    const queueTimeout = config.options.server.actionQueueTimeoutMs ?? 5e3;
+    this.actionSemaphore = new AsyncSemaphore(maxConcurrent, queueTimeout);
+    this.idempotencyTtlMs = config.options.server.idempotencyTtlMs ?? 12e4;
+    this.idempotencyScope = config.options.server.idempotencyScope ?? "connection";
     this.wss = new import_ws.WebSocketServer({
       host: config.options.server.host,
       port: config.options.server.port,
       path: config.options.server.path ?? "/shardwire",
       maxPayload: config.options.server.maxPayloadBytes ?? 65536
     });
-    this.wss.on("connection", (socket) => this.handleConnection(socket));
+    this.wss.on("connection", (socket, request) => this.handleConnection(socket, request));
     this.wss.on("error", (error) => this.logger.error("Bridge transport server error.", { error: String(error) }));
     this.interval = setInterval(() => {
       this.checkHeartbeats();
@@ -951,6 +1320,11 @@ var BridgeTransportServer = class {
   interval;
   connections = /* @__PURE__ */ new Map();
   stickyEvents = /* @__PURE__ */ new Map();
+  actionSemaphore;
+  idempotencyCache = /* @__PURE__ */ new Map();
+  idempotencyTtlMs;
+  idempotencyScope;
+  authBuckets = /* @__PURE__ */ new Map();
   connectionCount() {
     let count = 0;
     for (const state of this.connections.values()) {
@@ -994,12 +1368,14 @@ var BridgeTransportServer = class {
       });
     });
   }
-  handleConnection(socket) {
+  handleConnection(socket, request) {
+    const remoteAddress = request?.socket?.remoteAddress ?? "unknown";
     const state = {
       id: createConnectionId(),
       socket,
       authenticated: false,
       lastHeartbeatAt: Date.now(),
+      remoteAddress,
       subscriptions: /* @__PURE__ */ new Map()
     };
     this.connections.set(socket, state);
@@ -1050,6 +1426,21 @@ var BridgeTransportServer = class {
         state.socket.close(CLOSE_AUTH_REQUIRED, "Authentication required.");
         return;
       }
+      if (this.isAuthRateLimited(state.remoteAddress ?? "unknown")) {
+        this.logger.warn("Bridge auth rate limited.", { connectionId: state.id, remoteAddress: state.remoteAddress });
+        this.safeSend(
+          state.socket,
+          stringifyEnvelope(
+            makeEnvelope("auth.error", {
+              code: "UNAUTHORIZED",
+              reason: "invalid_secret",
+              message: "Too many authentication attempts. Try again later."
+            })
+          )
+        );
+        state.socket.close(CLOSE_AUTH_RATE_LIMITED, "Rate limited.");
+        return;
+      }
       const authResult = this.config.authenticate(envelope.payload);
       if (!authResult.ok) {
         const message = authResult.reason === "ambiguous_secret" ? "Authentication failed: secret matches multiple configured scopes. Supply secretId or use unique secret values." : "Authentication failed.";
@@ -1066,6 +1457,25 @@ var BridgeTransportServer = class {
         state.socket.close(CLOSE_AUTH_FAILED, "Invalid secret.");
         return;
       }
+      const maxConnections = this.config.options.server.maxConnections;
+      if (maxConnections !== void 0 && this.connectionCount() >= maxConnections) {
+        this.logger.warn("Bridge connection rejected: server full.", {
+          connectionId: state.id,
+          maxConnections
+        });
+        this.safeSend(
+          state.socket,
+          stringifyEnvelope(
+            makeEnvelope("auth.error", {
+              code: "UNAUTHORIZED",
+              reason: "invalid_secret",
+              message: "Server is at maximum connection capacity."
+            })
+          )
+        );
+        state.socket.close(CLOSE_SERVER_FULL, "Server full.");
+        return;
+      }
       state.authenticated = true;
       state.lastHeartbeatAt = Date.now();
       state.secret = authResult.secret;
@@ -1135,17 +1545,75 @@ var BridgeTransportServer = class {
         if (!requestId || !payload || typeof payload.name !== "string") {
           return;
         }
-        const result = await this.config.onActionRequest(
-          {
-            id: state.id,
-            ...state.appName ? { appName: state.appName } : {},
-            secret: state.secret,
-            capabilities: state.capabilities
-          },
-          payload.name,
-          payload.data,
-          requestId
-        );
+        const activeSecret = state.secret;
+        const activeCapabilities = state.capabilities;
+        if (!activeSecret || !activeCapabilities) {
+          state.socket.close(CLOSE_AUTH_FAILED, "Invalid state.");
+          return;
+        }
+        const idempotencyRaw = payload.idempotencyKey;
+        const idempotencyKey = typeof idempotencyRaw === "string" && idempotencyRaw.length > 0 && idempotencyRaw.length <= 256 ? idempotencyRaw : void 0;
+        const idempotencyCacheKey = idempotencyKey ? this.idempotencyScope === "secret" && activeSecret ? `secret:${activeSecret.id}:${idempotencyKey}` : `conn:${state.id}:${idempotencyKey}` : void 0;
+        if (idempotencyCacheKey) {
+          this.pruneIdempotencyCache(Date.now());
+          const cached = this.idempotencyCache.get(idempotencyCacheKey);
+          if (cached && cached.expires > Date.now()) {
+            const replay = cached.result.ok ? { ok: true, requestId, ts: Date.now(), data: cached.result.data } : { ok: false, requestId, ts: Date.now(), error: cached.result.error };
+            this.logger.info("Bridge action idempotent replay.", {
+              connectionId: state.id,
+              requestId,
+              action: payload.name
+            });
+            this.safeSend(
+              state.socket,
+              stringifyEnvelope(makeEnvelope(replay.ok ? "action.result" : "action.error", replay, { requestId }))
+            );
+            return;
+          }
+        }
+        const started = Date.now();
+        let result;
+        try {
+          result = await this.actionSemaphore.run(
+            () => this.config.onActionRequest(
+              {
+                id: state.id,
+                ...state.appName ? { appName: state.appName } : {},
+                secret: activeSecret,
+                capabilities: activeCapabilities
+              },
+              payload.name,
+              payload.data,
+              requestId
+            )
+          );
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Action queue saturated.";
+          result = {
+            ok: false,
+            requestId,
+            ts: Date.now(),
+            error: {
+              code: "SERVICE_UNAVAILABLE",
+              message,
+              details: { retryable: true, reason: "action_queue" }
+            }
+          };
+        }
+        if (idempotencyCacheKey) {
+          this.idempotencyCache.set(idempotencyCacheKey, {
+            result,
+            expires: Date.now() + this.idempotencyTtlMs
+          });
+        }
+        this.logger.info("Bridge action completed.", {
+          connectionId: state.id,
+          requestId,
+          action: payload.name,
+          durationMs: Date.now() - started,
+          ok: result.ok,
+          appName: state.appName
+        });
         this.safeSend(
           state.socket,
           stringifyEnvelope(makeEnvelope(result.ok ? "action.result" : "action.error", result, { requestId }))
@@ -1176,6 +1644,28 @@ var BridgeTransportServer = class {
       socket.send(payload);
     }
   }
+  isAuthRateLimited(remoteAddress) {
+    const windowMs = 6e4;
+    const limit = 40;
+    const now = Date.now();
+    let bucket = this.authBuckets.get(remoteAddress);
+    if (!bucket || now > bucket.resetAt) {
+      bucket = { count: 0, resetAt: now + windowMs };
+      this.authBuckets.set(remoteAddress, bucket);
+    }
+    bucket.count += 1;
+    return bucket.count > limit;
+  }
+  pruneIdempotencyCache(now) {
+    if (this.idempotencyCache.size < 200) {
+      return;
+    }
+    for (const [key, entry] of this.idempotencyCache.entries()) {
+      if (entry.expires <= now) {
+        this.idempotencyCache.delete(key);
+      }
+    }
+  }
 };
 function authenticateSecret(payload, secrets, resolver) {
   if (!payload.secret) {
@@ -1267,11 +1757,7 @@ function normalizeSecretEntry(secret, index) {
     value: scoped.value,
     scope: {
       events: normalizeScopeList(scoped.allow?.events, BOT_EVENT_NAMES, `server.secrets[${index}].allow.events`),
-      actions: normalizeScopeList(
-        scoped.allow?.actions,
-        BOT_ACTION_NAMES,
-        `server.secrets[${index}].allow.actions`
-      )
+      actions: normalizeScopeList(scoped.allow?.actions, BOT_ACTION_NAMES, `server.secrets[${index}].allow.actions`)
     }
   };
 }
@@ -1289,6 +1775,23 @@ function assertBotBridgeOptions(options) {
   if (options.server.maxPayloadBytes !== void 0) {
     assertPositiveNumber("server.maxPayloadBytes", options.server.maxPayloadBytes);
   }
+  if (options.server.maxConnections !== void 0) {
+    assertPositiveNumber("server.maxConnections", options.server.maxConnections);
+  }
+  if (options.server.maxConcurrentActions !== void 0) {
+    assertPositiveNumber("server.maxConcurrentActions", options.server.maxConcurrentActions);
+  }
+  if (options.server.actionQueueTimeoutMs !== void 0) {
+    assertPositiveNumber("server.actionQueueTimeoutMs", options.server.actionQueueTimeoutMs);
+  }
+  if (options.server.idempotencyScope !== void 0) {
+    if (options.server.idempotencyScope !== "connection" && options.server.idempotencyScope !== "secret") {
+      throw new Error('server.idempotencyScope must be "connection" or "secret".');
+    }
+  }
+  if (options.server.idempotencyTtlMs !== void 0) {
+    assertPositiveNumber("server.idempotencyTtlMs", options.server.idempotencyTtlMs);
+  }
   if (!Array.isArray(options.server.secrets) || options.server.secrets.length === 0) {
     throw new Error("server.secrets must contain at least one secret.");
   }
@@ -1488,9 +1991,28 @@ var AppRequestError = class extends Error {
   code;
 };
 var DEFAULT_REQUEST_TIMEOUT_MS = 1e4;
+function metricsExtrasFromActionError(error) {
+  const details = error.details;
+  if (!details || typeof details !== "object" || Array.isArray(details)) {
+    return {};
+  }
+  const obj = details;
+  const extras = {};
+  if (typeof obj.retryAfterMs === "number" && Number.isFinite(obj.retryAfterMs)) {
+    extras.retryAfterMs = obj.retryAfterMs;
+  }
+  if (typeof obj.discordStatus === "number" && Number.isFinite(obj.discordStatus)) {
+    extras.discordStatus = obj.discordStatus;
+  }
+  if (typeof obj.discordCode === "number" && Number.isFinite(obj.discordCode)) {
+    extras.discordCode = obj.discordCode;
+  }
+  return extras;
+}
 function connectBotBridge(options) {
   assertAppBridgeOptions(options);
   const logger = withLogger(options.logger);
+  const metrics = options.metrics;
   const reconnectEnabled = options.reconnect?.enabled ?? true;
   const initialDelayMs = options.reconnect?.initialDelayMs ?? 500;
   const maxDelayMs = options.reconnect?.maxDelayMs ?? 1e4;
@@ -1763,6 +2285,7 @@ function connectBotBridge(options) {
     }
     const requestId = sendOptions?.requestId ?? createRequestId();
     const timeoutMs = sendOptions?.timeoutMs ?? requestTimeoutMs;
+    const started = Date.now();
     const promise = new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
         pendingRequests.delete(requestId);
@@ -1780,16 +2303,32 @@ function connectBotBridge(options) {
           "action.request",
           {
             name,
-            data: payload
+            data: payload,
+            ...sendOptions?.idempotencyKey ? { idempotencyKey: sendOptions.idempotencyKey } : {}
           },
           { requestId }
         )
       )
     );
     try {
-      return await promise;
+      const result = await promise;
+      metrics?.onActionComplete?.({
+        name,
+        requestId,
+        durationMs: Date.now() - started,
+        ok: result.ok,
+        ...!result.ok ? { errorCode: result.error.code, ...metricsExtrasFromActionError(result.error) } : {}
+      });
+      return result;
     } catch (error) {
       const code = error instanceof AppRequestError ? error.code : !socket || socket.readyState !== 1 ? "DISCONNECTED" : "TIMEOUT";
+      metrics?.onActionComplete?.({
+        name,
+        requestId,
+        durationMs: Date.now() - started,
+        ok: false,
+        errorCode: code
+      });
       return {
         ok: false,
         requestId,
@@ -1807,7 +2346,14 @@ function connectBotBridge(options) {
     deleteMessage: (payload, sendOptions) => invokeAction("deleteMessage", payload, sendOptions),
     replyToInteraction: (payload, sendOptions) => invokeAction("replyToInteraction", payload, sendOptions),
     deferInteraction: (payload, sendOptions) => invokeAction("deferInteraction", payload, sendOptions),
+    deferUpdateInteraction: (payload, sendOptions) => invokeAction("deferUpdateInteraction", payload, sendOptions),
     followUpInteraction: (payload, sendOptions) => invokeAction("followUpInteraction", payload, sendOptions),
+    editInteractionReply: (payload, sendOptions) => invokeAction("editInteractionReply", payload, sendOptions),
+    deleteInteractionReply: (payload, sendOptions) => invokeAction("deleteInteractionReply", payload, sendOptions),
+    updateInteraction: (payload, sendOptions) => invokeAction("updateInteraction", payload, sendOptions),
+    showModal: (payload, sendOptions) => invokeAction("showModal", payload, sendOptions),
+    fetchMessage: (payload, sendOptions) => invokeAction("fetchMessage", payload, sendOptions),
+    fetchMember: (payload, sendOptions) => invokeAction("fetchMember", payload, sendOptions),
     banMember: (payload, sendOptions) => invokeAction("banMember", payload, sendOptions),
     kickMember: (payload, sendOptions) => invokeAction("kickMember", payload, sendOptions),
     addMemberRole: (payload, sendOptions) => invokeAction("addMemberRole", payload, sendOptions),