oft-agt 0.5.1 → 0.5.7

package/runtime/errors.mjs

@@ -1,85 +1,85 @@
-// Public diagnostics only. Never interpolate Discord error.message, request bodies or URLs.
-const ERRORS = {
-  MESSAGE_SEND_FAILED: ['Envoi impossible', 'Le message n’a pas pu être envoyé. Vérifiez le salon, les accès et le contenu.'],
-  MESSAGE_EDIT_FAILED: ['Modification impossible', 'Le message n’a pas pu être modifié. Vérifiez qu’il existe et appartient au bot.'],
-  MESSAGE_DELETE_FAILED: ['Suppression impossible', 'Le message n’a pas pu être supprimé. Vérifiez son existence et les permissions du bot.'],
-  CHANNEL_UNAVAILABLE: ['Salon inaccessible', 'Le salon est introuvable ou ne permet pas d’envoyer de messages.'],
-  USER_UNAVAILABLE: ['Destinataire inaccessible', 'L’utilisateur est introuvable ou ne peut pas recevoir de message privé.'],
-  MESSAGE_NOT_FOUND: ['Message introuvable', 'Le message cible n’existe plus ou le bloc qui devait l’envoyer n’a pas encore été exécuté.'],
-  MESSAGE_EMPTY: ['Message vide', 'Ajoutez du texte ou au moins un embed renseigné.'],
-  MESSAGE_TOO_LONG: ['Message trop long', 'Le texte du message dépasse 2 000 caractères. Réduisez-le ou utilisez un embed.'],
-  TOO_MANY_EMBEDS: ['Trop d’embeds', 'Un message du Builder accepte au maximum 5 embeds.'],
-  EMBED_TITLE_TOO_LONG: ['Titre d’embed trop long', 'Le titre d’un embed dépasse 256 caractères.'],
-  EMBED_DESCRIPTION_TOO_LONG: ['Description d’embed trop longue', 'La description d’un embed dépasse 4 096 caractères.'],
-  EMBED_AUTHOR_TOO_LONG: ['Auteur d’embed trop long', 'Le nom de l’auteur d’un embed dépasse 256 caractères.'],
-  EMBED_FOOTER_TOO_LONG: ['Pied de page trop long', 'Le pied de page d’un embed dépasse 2 048 caractères.'],
-  EMBED_FIELDS_INVALID: ['Champs d’embed invalides', 'Utilisez au maximum 25 champs par embed, avec un nom de 1 à 256 caractères et une valeur de 1 à 1 024 caractères.'],
-  EMBEDS_TOO_LARGE: ['Embeds trop volumineux', 'Le texte de l’ensemble des embeds dépasse 6 000 caractères.'],
-  MESSAGE_INVALID: ['Message invalide', 'Vérifiez les champs obligatoires, la couleur, les URL des images et les identifiants de destination.'],
-  INVALID_WAIT: ['Délai invalide', 'Le délai doit être un nombre compris entre 0 et 300 secondes.'],
-  TIMEOUT: ['Délai dépassé', 'L’action a dépassé son délai maximal. Vérifiez la connexion et réduisez les attentes.'],
-  NETWORK_ERROR: ['Connexion interrompue', 'La connexion à Discord a échoué. Vérifiez le réseau du serveur puis réessayez.'],
-  RATE_LIMITED: ['Trop de requêtes', 'Discord limite temporairement les actions du bot. Attendez avant de réessayer.'],
-  DISCORD_UNAVAILABLE: ['Discord indisponible', 'Discord rencontre une erreur temporaire. Réessayez dans quelques instants.'],
-  EXECUTION_FAILED: ['Erreur d’exécution', 'L’action n’a pas pu être effectuée. Vérifiez sa configuration et les accès du bot.'],
-};
-const DISCORD = {
-  10003: ['Salon introuvable', 'Le salon a été supprimé ou son identifiant est incorrect.'],
-  10008: ['Message introuvable', 'Le message a été supprimé ou son identifiant est incorrect.'],
-  10013: ['Utilisateur introuvable', 'Vérifiez l’identifiant du destinataire.'],
-  10062: ['Commande expirée', 'Le délai de réponse de la commande est dépassé.'],
-  40005: ['Message trop volumineux', 'Réduisez la taille du message ou de ses pièces jointes.'],
-  40058: ['Salon forum incompatible', 'Envoyez le message dans un salon textuel ou dans un fil existant du forum.'],
-  40060: ['Commande déjà acquittée', 'Cette commande a déjà reçu une réponse initiale. Utilisez une modification ou une réponse supplémentaire.'],
-  40094: ['Trop de réponses', 'La limite de réponses supplémentaires de cette commande est atteinte.'],
-  50001: ['Accès refusé', 'Le bot ne peut pas accéder à cette ressource.'],
-  50005: ['Modification interdite', 'Un bot ne peut modifier que ses propres messages.'],
-  50006: ERRORS.MESSAGE_EMPTY,
-  50007: ['Message privé impossible', 'Le destinataire ne peut pas recevoir de messages privés.'],
-  50008: ['Salon incompatible', 'Ce salon ne permet pas l’envoi de messages textuels.'],
-  50013: ['Permissions insuffisantes', 'Vérifiez les permissions Voir le salon, Envoyer des messages, Intégrer des liens et, pour une suppression, Gérer les messages.'],
-  50014: ['Authentification refusée', 'Le token du bot est invalide ou révoqué. Remplacez-le depuis Paramètres.'],
-  50021: ['Message système protégé', 'Discord interdit cette action sur un message système.'],
-  50024: ['Action incompatible', 'Cette action n’est pas disponible dans ce type de salon.'],
-  50034: ['Messages trop anciens', 'Discord refuse la suppression groupée de messages de plus de 14 jours.'],
-  50035: ['Contenu refusé par Discord', 'Vérifiez la taille du message, des embeds, des champs et les formats des paramètres.'],
-  50045: ['Fichier trop volumineux', 'La pièce jointe dépasse la taille autorisée par Discord.'],
-  50083: ['Fil archivé', 'Désarchivez le fil avant d’y envoyer ou d’y modifier un message.'],
-  200000: ['Message bloqué par AutoMod', 'Le contenu du message a été refusé par la modération automatique du serveur.'],
-  240000: ['Lien bloqué', 'Discord a bloqué un lien jugé dangereux dans le message.'],
-};
-export function runtimeError(code, operation, cause) {
-  return Object.assign(new Error(code), { code, operation, cause });
-}
-export function errorVariables(error, action, blockId) {
-  let current = error, diagnostic, code;
-  for (let depth = 0; current && depth < 5; depth++, current = current.cause) {
-    if (Object.hasOwn(DISCORD, current.code)) { diagnostic = DISCORD[current.code]; code = 'DISCORD_' + current.code; break; }
-    if (Object.hasOwn(ERRORS, current.code)) { diagnostic = ERRORS[current.code]; code = current.code; break; }
-    if (current.name === 'AbortError' || current.name === 'TimeoutError') code = 'TIMEOUT';
-    else if (['ECONNRESET', 'ECONNREFUSED', 'ENOTFOUND', 'ETIMEDOUT', 'EAI_AGAIN', 'UND_ERR_CONNECT_TIMEOUT', 'UND_ERR_SOCKET'].includes(current.code)) code = current.code === 'ETIMEDOUT' ? 'TIMEOUT' : 'NETWORK_ERROR';
-    else if (current.status === 429) code = 'RATE_LIMITED';
-    else if (Number.isInteger(current.status) && current.status >= 500 && current.status <= 599) code = 'DISCORD_UNAVAILABLE';
-    if (code) { diagnostic = ERRORS[code]; break; }
-  }
-  const fallback = { sendMessage: 'MESSAGE_SEND_FAILED', editMessage: 'MESSAGE_EDIT_FAILED', deleteMessage: 'MESSAGE_DELETE_FAILED' };
-  const requested = error?.operation || action;
-  code ||= Object.hasOwn(fallback, requested) ? fallback[requested] : 'EXECUTION_FAILED'; diagnostic ||= ERRORS[code];
-  const operations = { sendMessage: 'L’envoi du message a échoué.', editMessage: 'La modification du message a échoué.', deleteMessage: 'La suppression du message a échoué.', wait: 'L’attente a été interrompue.' };
-  const operation = Object.hasOwn(operations, error?.operation) ? error.operation : action;
-  const safeBlockId = typeof blockId === 'string' && /^[\w-]{1,64}$/.test(blockId) ? blockId : '';
-  return { error_name: diagnostic[0], error_desc: operations[operation] || 'La commande n’a pas pu être exécutée.', error_reason: diagnostic[1], error_code: code, error_block_id: safeBlockId };
-}
-
-export function validateMessage(config) {
-  if ((config.text || '').length > 2000) throw runtimeError('MESSAGE_TOO_LONG');
-  if ((config.embeds || []).length > 5) throw runtimeError('TOO_MANY_EMBEDS');
-  let total = 0;
-  for (const embed of config.embeds || []) {
-    for (const [value, limit, code] of [[embed.title, 256, 'EMBED_TITLE_TOO_LONG'], [embed.description, 4096, 'EMBED_DESCRIPTION_TOO_LONG'], [embed.author?.name, 256, 'EMBED_AUTHOR_TOO_LONG'], [embed.footer?.text, 2048, 'EMBED_FOOTER_TOO_LONG']]) { if ((value || '').length > limit) throw runtimeError(code); total += (value || '').length; }
-    if ((embed.fields || []).length > 25 || (embed.fields || []).some(field => !field.name?.trim() || !field.value?.trim() || field.name.length > 256 || field.value.length > 1024)) throw runtimeError('EMBED_FIELDS_INVALID');
-    total += (embed.fields || []).reduce((sum, field) => sum + field.name.length + field.value.length, 0);
-  }
-  if (total > 6000) throw runtimeError('EMBEDS_TOO_LARGE');
-  if (!config.text?.trim() && !config.embeds?.length) throw runtimeError('MESSAGE_EMPTY');
-}
+// Public diagnostics only. Never interpolate Discord error.message, request bodies or URLs.
+const ERRORS = {
+  MESSAGE_SEND_FAILED: ['Envoi impossible', 'Le message n’a pas pu être envoyé. Vérifiez le salon, les accès et le contenu.'],
+  MESSAGE_EDIT_FAILED: ['Modification impossible', 'Le message n’a pas pu être modifié. Vérifiez qu’il existe et appartient au bot.'],
+  MESSAGE_DELETE_FAILED: ['Suppression impossible', 'Le message n’a pas pu être supprimé. Vérifiez son existence et les permissions du bot.'],
+  CHANNEL_UNAVAILABLE: ['Salon inaccessible', 'Le salon est introuvable ou ne permet pas d’envoyer de messages.'],
+  USER_UNAVAILABLE: ['Destinataire inaccessible', 'L’utilisateur est introuvable ou ne peut pas recevoir de message privé.'],
+  MESSAGE_NOT_FOUND: ['Message introuvable', 'Le message cible n’existe plus ou le bloc qui devait l’envoyer n’a pas encore été exécuté.'],
+  MESSAGE_EMPTY: ['Message vide', 'Ajoutez du texte ou au moins un embed renseigné.'],
+  MESSAGE_TOO_LONG: ['Message trop long', 'Le texte du message dépasse 2 000 caractères. Réduisez-le ou utilisez un embed.'],
+  TOO_MANY_EMBEDS: ['Trop d’embeds', 'Un message du Builder accepte au maximum 5 embeds.'],
+  EMBED_TITLE_TOO_LONG: ['Titre d’embed trop long', 'Le titre d’un embed dépasse 256 caractères.'],
+  EMBED_DESCRIPTION_TOO_LONG: ['Description d’embed trop longue', 'La description d’un embed dépasse 4 096 caractères.'],
+  EMBED_AUTHOR_TOO_LONG: ['Auteur d’embed trop long', 'Le nom de l’auteur d’un embed dépasse 256 caractères.'],
+  EMBED_FOOTER_TOO_LONG: ['Pied de page trop long', 'Le pied de page d’un embed dépasse 2 048 caractères.'],
+  EMBED_FIELDS_INVALID: ['Champs d’embed invalides', 'Utilisez au maximum 25 champs par embed, avec un nom de 1 à 256 caractères et une valeur de 1 à 1 024 caractères.'],
+  EMBEDS_TOO_LARGE: ['Embeds trop volumineux', 'Le texte de l’ensemble des embeds dépasse 6 000 caractères.'],
+  MESSAGE_INVALID: ['Message invalide', 'Vérifiez les champs obligatoires, la couleur, les URL des images et les identifiants de destination.'],
+  INVALID_WAIT: ['Délai invalide', 'Le délai doit être un nombre compris entre 0 et 300 secondes.'],
+  TIMEOUT: ['Délai dépassé', 'L’action a dépassé son délai maximal. Vérifiez la connexion et réduisez les attentes.'],
+  NETWORK_ERROR: ['Connexion interrompue', 'La connexion à Discord a échoué. Vérifiez le réseau du serveur puis réessayez.'],
+  RATE_LIMITED: ['Trop de requêtes', 'Discord limite temporairement les actions du bot. Attendez avant de réessayer.'],
+  DISCORD_UNAVAILABLE: ['Discord indisponible', 'Discord rencontre une erreur temporaire. Réessayez dans quelques instants.'],
+  EXECUTION_FAILED: ['Erreur d’exécution', 'L’action n’a pas pu être effectuée. Vérifiez sa configuration et les accès du bot.'],
+};
+const DISCORD = {
+  10003: ['Salon introuvable', 'Le salon a été supprimé ou son identifiant est incorrect.'],
+  10008: ['Message introuvable', 'Le message a été supprimé ou son identifiant est incorrect.'],
+  10013: ['Utilisateur introuvable', 'Vérifiez l’identifiant du destinataire.'],
+  10062: ['Commande expirée', 'Le délai de réponse de la commande est dépassé.'],
+  40005: ['Message trop volumineux', 'Réduisez la taille du message ou de ses pièces jointes.'],
+  40058: ['Salon forum incompatible', 'Envoyez le message dans un salon textuel ou dans un fil existant du forum.'],
+  40060: ['Commande déjà acquittée', 'Cette commande a déjà reçu une réponse initiale. Utilisez une modification ou une réponse supplémentaire.'],
+  40094: ['Trop de réponses', 'La limite de réponses supplémentaires de cette commande est atteinte.'],
+  50001: ['Accès refusé', 'Le bot ne peut pas accéder à cette ressource.'],
+  50005: ['Modification interdite', 'Un bot ne peut modifier que ses propres messages.'],
+  50006: ERRORS.MESSAGE_EMPTY,
+  50007: ['Message privé impossible', 'Le destinataire ne peut pas recevoir de messages privés.'],
+  50008: ['Salon incompatible', 'Ce salon ne permet pas l’envoi de messages textuels.'],
+  50013: ['Permissions insuffisantes', 'Vérifiez les permissions Voir le salon, Envoyer des messages, Intégrer des liens et, pour une suppression, Gérer les messages.'],
+  50014: ['Authentification refusée', 'Le token du bot est invalide ou révoqué. Remplacez-le depuis Paramètres.'],
+  50021: ['Message système protégé', 'Discord interdit cette action sur un message système.'],
+  50024: ['Action incompatible', 'Cette action n’est pas disponible dans ce type de salon.'],
+  50034: ['Messages trop anciens', 'Discord refuse la suppression groupée de messages de plus de 14 jours.'],
+  50035: ['Contenu refusé par Discord', 'Vérifiez la taille du message, des embeds, des champs et les formats des paramètres.'],
+  50045: ['Fichier trop volumineux', 'La pièce jointe dépasse la taille autorisée par Discord.'],
+  50083: ['Fil archivé', 'Désarchivez le fil avant d’y envoyer ou d’y modifier un message.'],
+  200000: ['Message bloqué par AutoMod', 'Le contenu du message a été refusé par la modération automatique du serveur.'],
+  240000: ['Lien bloqué', 'Discord a bloqué un lien jugé dangereux dans le message.'],
+};
+export function runtimeError(code, operation, cause) {
+  return Object.assign(new Error(code), { code, operation, cause });
+}
+export function errorVariables(error, action, blockId) {
+  let current = error, diagnostic, code;
+  for (let depth = 0; current && depth < 5; depth++, current = current.cause) {
+    if (Object.hasOwn(DISCORD, current.code)) { diagnostic = DISCORD[current.code]; code = 'DISCORD_' + current.code; break; }
+    if (Object.hasOwn(ERRORS, current.code)) { diagnostic = ERRORS[current.code]; code = current.code; break; }
+    if (current.name === 'AbortError' || current.name === 'TimeoutError') code = 'TIMEOUT';
+    else if (['ECONNRESET', 'ECONNREFUSED', 'ENOTFOUND', 'ETIMEDOUT', 'EAI_AGAIN', 'UND_ERR_CONNECT_TIMEOUT', 'UND_ERR_SOCKET'].includes(current.code)) code = current.code === 'ETIMEDOUT' ? 'TIMEOUT' : 'NETWORK_ERROR';
+    else if (current.status === 429) code = 'RATE_LIMITED';
+    else if (Number.isInteger(current.status) && current.status >= 500 && current.status <= 599) code = 'DISCORD_UNAVAILABLE';
+    if (code) { diagnostic = ERRORS[code]; break; }
+  }
+  const fallback = { sendMessage: 'MESSAGE_SEND_FAILED', editMessage: 'MESSAGE_EDIT_FAILED', deleteMessage: 'MESSAGE_DELETE_FAILED' };
+  const requested = error?.operation || action;
+  code ||= Object.hasOwn(fallback, requested) ? fallback[requested] : 'EXECUTION_FAILED'; diagnostic ||= ERRORS[code];
+  const operations = { sendMessage: 'L’envoi du message a échoué.', editMessage: 'La modification du message a échoué.', deleteMessage: 'La suppression du message a échoué.', wait: 'L’attente a été interrompue.' };
+  const operation = Object.hasOwn(operations, error?.operation) ? error.operation : action;
+  const safeBlockId = typeof blockId === 'string' && /^[\w-]{1,64}$/.test(blockId) ? blockId : '';
+  return { error_name: diagnostic[0], error_desc: operations[operation] || 'La commande n’a pas pu être exécutée.', error_reason: diagnostic[1], error_code: code, error_block_id: safeBlockId };
+}
+
+export function validateMessage(config) {
+  if ((config.text || '').length > 2000) throw runtimeError('MESSAGE_TOO_LONG');
+  if ((config.embeds || []).length > 5) throw runtimeError('TOO_MANY_EMBEDS');
+  let total = 0;
+  for (const embed of config.embeds || []) {
+    for (const [value, limit, code] of [[embed.title, 256, 'EMBED_TITLE_TOO_LONG'], [embed.description, 4096, 'EMBED_DESCRIPTION_TOO_LONG'], [embed.author?.name, 256, 'EMBED_AUTHOR_TOO_LONG'], [embed.footer?.text, 2048, 'EMBED_FOOTER_TOO_LONG']]) { if ((value || '').length > limit) throw runtimeError(code); total += (value || '').length; }
+    if ((embed.fields || []).length > 25 || (embed.fields || []).some(field => !field.name?.trim() || !field.value?.trim() || field.name.length > 256 || field.value.length > 1024)) throw runtimeError('EMBED_FIELDS_INVALID');
+    total += (embed.fields || []).reduce((sum, field) => sum + field.name.length + field.value.length, 0);
+  }
+  if (total > 6000) throw runtimeError('EMBEDS_TOO_LARGE');
+  if (!config.text?.trim() && !config.embeds?.length && !config.buttons?.length) throw runtimeError('MESSAGE_EMPTY');
+}

package/runtime/execute.mjs

@@ -1,75 +1,198 @@
-import { matchesCondition, validateCondition } from './conditions.mjs';
+import { interpolateVariables, referencedVariables, VARIABLE_WARNING_CODES } from './custom-variables.mjs';
+import { variableRuntimeOptions } from './variable-actions.mjs';
+import { buttonRouter } from './button-router.mjs';
+import { contextVariables } from './context-variables.mjs';
+
+import { getScheduler } from './scheduler.mjs';
+
+import { matchesCondition, selectConditionBranch, validateCondition } from './conditions.mjs';
+
 import { resolveOptions, interpolateOptions } from './options.mjs';
+
 import { FUNCTIONS } from './functions.mjs';
+
 import { errorVariables } from './errors.mjs';
+
 export { errorVariables } from './errors.mjs';
 
+
+
 /** Each invocation gets its own context; no messages or secrets are shared across users. */
+
 export async function executeCommand(command, interaction, client, options = {}) {
+
+  const scheduler = options.scheduler || getScheduler();
+
+  const release = scheduler.admit();
+
+  // Include acknowledgement and queue time in Discord's interaction lifetime.
+
+  const remaining = Math.min(870000, (interaction.createdTimestamp || Date.now()) + 870000 - Date.now());
+
+  if (remaining <= 0) { release(); throw new Error('Interaction expirée.'); }
+
+  const deadline = AbortSignal.timeout(Math.max(0, remaining));
+
+  const signal = options.signal ? AbortSignal.any([options.signal, deadline]) : deadline;
+
+  const warnings = new Set(), started = performance.now(); let success = true;
+  try { return await executeAdmitted(command, interaction, client, { ...options, scheduler, signal, onError: () => { success = false; options.onError?.(); }, onWarning: code => { if (VARIABLE_WARNING_CODES.includes(code)) warnings.add(code); options.onWarning?.(code); } }); }
+  catch (error) { success = false; throw error; }
+  finally {
+    release();
+    try { options.onExecution?.({ command: command.name, success, durationMs: Math.min(900000, Math.round(performance.now() - started)), warningCodes: [...warnings] }); } catch {}
+  }
+
+}
+
+
+
+async function executeAdmitted(command, interaction, client, options) {
+
   const registry = options.functions || FUNCTIONS;
+
   let count = 0;
+
   function validate(calls, depth = 0) {
+
     if (!Array.isArray(calls) || depth > 32) throw new Error('Plan d’exécution invalide.');
+
     for (const call of calls) {
+
       if (++count > 500) throw new Error('Plan d’exécution trop volumineux.');
+
       if (call.fn === 'condition') {
+
         const { rules } = validateCondition(call.args?.kind, call.args);
+
         if (!Array.isArray(call.branches) || call.branches.length !== rules.length || !call.otherwise) throw new Error('Branches invalides.');
+
         rules.forEach((rule, index) => { if (call.branches[index].ruleId !== rule.id) throw new Error('Branche invalide.'); validate(call.branches[index].calls, depth + 1); });
+
         validate(call.otherwise.calls, depth + 1);
+
       } else if (!Object.hasOwn(registry, call.fn)) throw new Error('Fonction inconnue.');
+
     }
+
   }
+
   const errorCalls = command.errorCalls || [];
+
   validate(command.calls); validate(errorCalls);
-  const optionValues = { ...resolveOptions(command.options, interaction), user_id: interaction.user?.id || '', user_name: interaction.user?.username || '', channel_id: interaction.channelId || '' };
-  function select(calls, variables = optionValues) {
-    return calls.flatMap(call => {
-      if (call.fn !== 'condition') return [call];
-      const args = interpolateOptions(call.args, variables);
-      const index = args.rules.findIndex(rule => matchesCondition(args.kind, rule, interaction));
-      return select(index < 0 ? call.otherwise.calls : call.branches[index].calls, variables);
-    });
-  }
-  const selectedCalls = select(command.calls);
-  const firstReply = [...selectedCalls].find(call => call.fn === 'sendMessage' && call.args.sendMode === 'reply' && call.args.replyMode === 'command');
-  const privateAck = !firstReply || Boolean(firstReply.args.ephemeral);
+
+  const optionValues = { ...(options.buttonSnapshot?.variables || resolveOptions(command.options, interaction)), ...contextVariables(interaction, client) };
+
+  optionValues.command_name=command.name;
+  const usesCustomVariables = Boolean(JSON.stringify(command).includes('randomCondition') || referencedVariables(command).length || JSON.stringify(command).includes('"fn":"setVariable"') || JSON.stringify(command).includes('"fn":"deleteVariable"'));
+  const privateAck = usesCustomVariables || (() => {
+    function flatten(calls) { return calls.flatMap(call => call.fn !== 'condition' ? [call] : (() => { const args = interpolateOptions(call.args, optionValues); const index = selectConditionBranch(args.kind, args.rules, interaction, options.random); return flatten(index < 0 ? call.otherwise.calls : call.branches[index].calls); })()); }
+    const firstReply = flatten(command.calls).find(call => call.fn === 'sendMessage' && call.args.sendMode === 'reply' && call.args.replyMode === 'command');
+    return !firstReply || Boolean(firstReply.args.ephemeral);
+  })();
   await interaction.deferReply(privateAck ? { flags: 64 } : {});
-  const context = { interaction, client, messages: new Map(), hasCommandReply: false, signal: options.signal || AbortSignal.timeout(870_000) };
+  if (options.signal.aborted) throw options.signal.reason;
+  const context = { interaction, client, messages: new Map(options.buttonSnapshot?.messages), channels: new Map(options.buttonSnapshot?.channels), hasCommandReply: false, signal: options.signal || AbortSignal.timeout(870000), variableStore: options.variableStore, variableReplyMode: usesCustomVariables };
+  const definitions = options.variableDefinitions || [];
+  const warn = code => options.onWarning?.(code);
+  context.variableOptions = variableRuntimeOptions(context, optionValues, definitions, options.variableStore, warn);
+  async function* select(calls, variables = optionValues) {
+    for (const call of calls) {
+      if (call.fn !== 'condition') { yield call; continue; }
+      const args = await interpolateVariables(call.args, { ...context.variableOptions, base: { ...context.variableOptions.base, ...variables } });
+      const index = selectConditionBranch(args.kind, args.rules, interaction, options.random);
+      yield* select(index < 0 ? call.otherwise.calls : call.branches[index].calls, variables);
+    }
+  }
   let failedCall;
-  try { for (const call of selectedCalls) {
+
+  try { for await (const call of select(command.calls)) {
+
     failedCall = call;
+
     context.signal.throwIfAborted();
-    const result = await registry[call.fn](context, interpolateOptions(call.args, optionValues));
+
+    const args=await interpolateVariables(call.args,context.variableOptions);
+    const prepared=call.fn==='sendMessage'&&args.buttons?.length?(options.buttonRouter||buttonRouter).prepare(command,args.buttons,context,optionValues):null;
+    const invoke=async()=>{try{return await registry[call.fn](context,{...args,...(prepared?{components:prepared.components}:{})});}catch(error){prepared?.cancel();throw error;}};
+
+    let result;try{result=call.fn==='wait'?await invoke():await options.scheduler.run(invoke,{signal:context.signal});}catch(error){prepared?.cancel();throw error;}
+
     if (call.fn === 'sendMessage') context.messages.set(call.id, result);
+    prepared?.bind(result);
+
+    if (call.fn === 'createChannel') context.channels.set(call.id, result);
+
   } } catch (error) {
+
     options.onError?.();
+
     if (!errorCalls.length) throw error;
+
     const variables = errorVariables(error, failedCall?.fn, failedCall?.id);
+
     // A fresh, bounded error context prevents an expired main signal from skipping the handler.
-    context.signal = AbortSignal.timeout(30000);
-    for (const call of select(errorCalls, { ...optionValues, ...variables })) {
+
+    context.signal = AbortSignal.any([options.signal, AbortSignal.timeout(30000)]);
+
+    for await (const call of select(errorCalls, { ...optionValues, ...variables })) {
+
       context.signal.throwIfAborted();
-      const result = await registry[call.fn](context, interpolateError(interpolateOptions(call.args, optionValues), variables));
+
+      const args=interpolateError(await interpolateVariables(call.args,{...context.variableOptions,base:{...context.variableOptions.base,...optionValues,...variables}}),variables);
+    const prepared=call.fn==='sendMessage'&&args.buttons?.length?(options.buttonRouter||buttonRouter).prepare(command,args.buttons,context,{...optionValues,...variables}):null;
+    const invoke=async()=>{try{return await registry[call.fn](context,{...args,...(prepared?{components:prepared.components}:{})});}catch(error){prepared?.cancel();throw error;}};
+
+      let result;try{result=call.fn==='wait'?await invoke():await options.scheduler.run(invoke,{signal:context.signal});}catch(error){prepared?.cancel();throw error;}
+
       if (call.fn === 'sendMessage') context.messages.set(call.id, result);
+    prepared?.bind(result);
+
+    if (call.fn === 'createChannel') context.channels.set(call.id, result);
+
     }
+
   }
+
   // For commands that only send externally, remove the private loading acknowledgement.
-  if (!context.hasCommandReply) await interaction.deleteReply();
+
+  if (!context.hasCommandReply || context.removeDeferredReply) await interaction.deleteReply();
+
   return context.messages;
+
 }
 
+
+
 export function interpolateError(args, variables) {
+
   const result = structuredClone(args);
+
   const replace = (value, max) => typeof value === 'string' ? value.replace(/\{(error_name|error_desc|error_reason|error_code|error_block_id)\}/g, (_, key) => variables[key] || '').slice(0, max) : value;
+
   result.text = replace(result.text, 2000);
+
   let remaining = 6000;
+
   const embedText = (value, max) => { const text = replace(value, Math.min(max, remaining)); remaining -= text?.length || 0; return text; };
+
   for (const embed of result.embeds || []) {
+
     embed.title = embedText(embed.title, 256); embed.description = embedText(embed.description, 4096);
+
     if (embed.author) embed.author.name = embedText(embed.author.name, 256);
+
     if (embed.footer) embed.footer.text = embedText(embed.footer.text, 2048);
+
     for (const field of embed.fields || []) { field.name = embedText(field.name, 256); field.value = embedText(field.value, 1024); }
+
   }
+
   return result;
+
+}
+
+
+export async function executeButtonInteraction(interaction,client,options={}) {
+ return (options.buttonRouter||buttonRouter).handle(interaction,record=>executeCommand({...record.command,calls:record.branch.calls,options:[]},interaction,client,{...options,buttonSnapshot:record.snapshot}));
 }

package/runtime/functions.mjs

@@ -1,48 +1,136 @@
+import { VARIABLE_ACTIONS } from './variable-actions.mjs';
+import { DISCORD_ACTIONS } from './discord-actions.mjs';
+
 import { setTimeout } from 'node:timers/promises';
+
 import { normalizeMessageConfig, messageConfigError, discordMessagePayload } from './message-config.mjs';
+
 import { runtimeError, validateMessage } from './errors.mjs';
 
+
+
+// Authorize the caller, not just the bot, before sending to a guild channel.
+
+async function authorizeChannel(interaction, channel) {
+
+  if (!interaction.guildId || channel?.guildId !== interaction.guildId || !interaction.user?.id || !interaction.guild) {
+
+    throw new Error('Destination Discord non autorisée.');
+
+  }
+
+  const member = await interaction.guild.members.fetch({ user: interaction.user.id, force: true });
+
+  const permissions = channel.permissionsFor(member);
+
+  const sendPermission = channel.isThread?.() ? 'SendMessagesInThreads' : 'SendMessages';
+
+  if (!permissions?.has(['ViewChannel', sendPermission])) throw new Error('Permissions Discord insuffisantes.');
+
+  // Private threads additionally require membership, unless the caller can manage threads.
+
+  if (channel.type === 12 && !permissions.has('ManageThreads')) {
+
+    const membership = await channel.members.fetch(interaction.user.id);
+
+    if (!membership) throw new Error('Fil privé inaccessible.');
+
+  }
+
+}
+
+
+
 async function sendMessage(context, parameters) {
+
   const config = normalizeMessageConfig(parameters);
+
   validateMessage(config);
+
   const error = messageConfigError(config, undefined, false);
+
   if (error) throw runtimeError('MESSAGE_INVALID');
-  const payload = discordMessagePayload(config);
+
+  const payload = {...discordMessagePayload(config),...(parameters.components?{components:parameters.components}:{})};
+
   const { interaction, client, messages } = context;
+
   if (config.sendMode === 'channel') {
-    const channel = config.channelMode === 'id' ? await client.channels.fetch(config.channelId) : interaction.channel;
+
+    const channel = config.channelMode === 'created' ? context.channels.get(config.createdChannelBlockId) : config.channelMode === 'id' ? await client.channels.fetch(config.channelId) : interaction.channel;
+
     if (!channel?.send) throw runtimeError('CHANNEL_UNAVAILABLE');
+
+    await authorizeChannel(interaction, channel);
+
     return channel.send(payload);
+
   }
+
   if (config.sendMode === 'dm') {
+
     const user = config.dmMode === 'id' ? await client.users.fetch(config.userId) : interaction.user;
+
     if (!user?.send) throw runtimeError('USER_UNAVAILABLE');
+
     return user.send(payload);
+
   }
+
   if (config.replyMode === 'block' || config.replyMode === 'message') {
+
     const message = config.replyMode === 'block' ? messages.get(config.targetBlockId) : await interaction.channel?.messages.fetch(config.messageId);
+
     if (!message?.reply) throw runtimeError('MESSAGE_NOT_FOUND');
+    if(message.guildId||message.channel?.guildId)await authorizeChannel(interaction,message.channel);
+
     return message.reply(payload);
+
   }
+
   if (!context.hasCommandReply) {
-    const message = await interaction.editReply(payload);
+
+    const message = context.variableReplyMode && !config.ephemeral ? await interaction.followUp({ ...payload, flags: 0 }) : await interaction.editReply(payload);
+    if (context.variableReplyMode && !config.ephemeral) context.removeDeferredReply = true;
+
     context.hasCommandReply = true;
+
     return message;
+
   }
+
   return interaction.followUp({ ...payload, ...(config.ephemeral ? { flags: 64 } : {}) });
+
 }
 
+
+
 async function wait(context, { seconds }) {
+
   if (!Number.isFinite(seconds) || seconds < 0 || seconds > 300) throw runtimeError('INVALID_WAIT');
+
   await setTimeout(seconds * 1000, undefined, { signal: context.signal });
+
 }
 
+
+
 async function deleteMessage(context, parameters) {
+
   if (parameters.deleteMode === 'manual' && !/^\d{17,20}$/.test(parameters.messageId || '')) throw runtimeError('MESSAGE_INVALID');
+
   const message = parameters.deleteMode === 'block' ? context.messages.get(parameters.targetBlockId) : await context.interaction.channel?.messages.fetch(parameters.messageId);
+
   if (!message?.delete) throw runtimeError('MESSAGE_NOT_FOUND');
+  if(message.guildId||message.channel?.guildId)await authorizeChannel(context.interaction,message.channel);
+
   await message.delete();
+
 }
 
+
+
 // Extend this registry together with compiler validation when adding a new block type.
-export const FUNCTIONS = Object.freeze(Object.assign(Object.create(null), Object.fromEntries(Object.entries({ sendMessage, wait, deleteMessage }).map(([name, fn]) => [name, async (context, args) => { try { return await fn(context, args); } catch (error) { throw runtimeError(undefined, name, error); } }]))));
+
+export const FUNCTIONS = Object.freeze(Object.assign(Object.create(null), Object.fromEntries(Object.entries({ sendMessage, wait, deleteMessage, ...DISCORD_ACTIONS, ...VARIABLE_ACTIONS }).map(([name, fn]) => [name, async (context, args) => { try { return await fn(context, args); } catch (error) { throw runtimeError(undefined, name, error); } }]))));
+

package/runtime/lifecycle.mjs

@@ -120,5 +120,5 @@ export async function removeLocalInstance(home, base, config) {
     await rm(directory, { recursive: true }); return;
   }
   if (directory !== root) throw new Error('INSTANCE_INVALID');
-  for (const item of ['installation', 'versions', 'releases', 'agent.json', 'agent.json.tmp', 'private.pem', 'discord-secret.json', 'auth-rotation.json', 'auth-rotation.json.tmp', 'auth-operation.lock', 'private.pem.tmp', 'discord-secret.json.tmp', 'agent-release.json', 'active.json', 'paused.json', 'agent.lock', 'daemon.json', 'daemon-stop.json', 'agent.log', 'agent.log.previous', 'usage.json']) await rm(path.join(directory, item), { recursive: true, force: true });
+  for (const item of ['installation', 'versions', 'releases', 'data', 'agent.json', 'agent.json.tmp', 'private.pem', 'discord-secret.json', 'auth-rotation.json', 'auth-rotation.json.tmp', 'auth-operation.lock', 'private.pem.tmp', 'discord-secret.json.tmp', 'agent-release.json', 'active.json', 'paused.json', 'agent.lock', 'daemon.json', 'daemon-stop.json', 'agent.log', 'agent.log.previous', 'usage.json']) await rm(path.join(directory, item), { recursive: true, force: true });
 }

package/runtime/message-buttons.mjs

@@ -0,0 +1,17 @@
+export const BUTTON_DEFAULTS = {label:'Bouton',style:1,emoji:'',disabled:false,url:'',skuId:'',row:0,order:0,authorOnly:true,once:false,lifetime:86400};
+export function validateButton(raw = {}, templates = true) {
+ const c=Object.fromEntries(Object.entries(BUTTON_DEFAULTS).map(([k,v])=>[k,raw[k]??v]));
+ c.style=Number(c.style);c.row=Number(c.row);c.order=Number(c.order);c.lifetime=Number(c.lifetime);
+ if(![1,2,3,4,5,6].includes(c.style)||!Number.isInteger(c.order)||c.order<0||c.order>24||!Number.isInteger(c.row)||c.row<0||c.row>4||!Number.isInteger(c.lifetime)||c.lifetime<60||c.lifetime>604800) throw Error('Style, ligne ou durée du bouton invalide.');
+ for(const key of ['disabled','authorOnly','once']) if(typeof c[key]!=='boolean') throw Error('Paramètre de bouton invalide.');
+ if(typeof c.label!=='string'||c.label.length>80||typeof c.emoji!=='string'||c.emoji.length>100) throw Error('Texte du bouton : 80 caractères maximum.');
+ if(c.style!==6&&!c.label.trim()&&!c.emoji) throw Error('Ajoutez un texte ou un emoji au bouton.');
+ if(c.style===5){if(typeof c.url!=='string'||c.url.length>512)throw Error('URL du bouton invalide.');try{if(!(templates&&/\{[a-zA-Z0-9_-]+\}/.test(c.url))&&!['http:','https:'].includes(new URL(c.url).protocol))throw Error();}catch{throw Error('Le lien doit être une URL HTTP ou HTTPS.');}}
+ if(c.style===6&&!/^\d{17,20}$/.test(c.skuId))throw Error('Identifiant SKU Discord requis.');
+ return c;
+}
+export function buttonComponent(config, customId) {
+ const c=validateButton(config,false);
+ const emoji=c.emoji.match(/^<(a?):([a-zA-Z0-9_]+):(\d{17,20})>$/);
+ return {type:2,style:c.style,disabled:c.disabled,...(c.style===6?{sku_id:c.skuId}:{...(c.label?{label:c.label}:{}),...(c.emoji?{emoji:emoji?{id:emoji[3],name:emoji[2],animated:Boolean(emoji[1])}:{name:c.emoji}}:{}),...(c.style===5?{url:c.url}:{custom_id:customId})})};
+}