@manybot/manybot 5.8.0 → 5.9.1

package/dist/kernel/commandsConfig.test.js

@@ -32,6 +32,7 @@ describe("kernel/commandsConfig", () => {
         assert.ok(config);
         assert.equal(config.defaults.notifyChanges, true);
         assert.equal(config.defaults.notifyPeriodDays, 7);
+        assert.equal(config.menu.enabled, false);
         assert.deepEqual(config.menu.aliases, ["help", "man", "menu", "bot", "?"]);
         assert.deepEqual(config.specs, []);
     });
@@ -109,16 +110,36 @@ missingCmd:
                 cooldownSeconds: 4,
                 whitelist: { groups: ["group@g.us"], users: ["user@c.us"] },
                 blacklist: undefined,
+                dono: undefined,
+                allowedChats: undefined,
+                groupOnly: undefined,
+                dmOnly: undefined,
+                whitelistGroups: undefined,
+                blacklistUsers: undefined,
+                hiddenOutsideScope: undefined,
             },
-            messages: { botNotAdmin: undefined, senderNotAdmin: undefined, ownerOnly: undefined, wrongScope: undefined, cooldown: "Wait" },
+            messages: {
+                botNotAdmin: undefined,
+                senderNotAdmin: undefined,
+                ownerOnly: undefined,
+                donoOnly: undefined,
+                wrongScope: undefined,
+                cooldown: "Wait",
+                blacklist: undefined,
+                allowedChats: undefined,
+            },
+            loading: null,
         });
         assert.deepEqual(config.menu, {
+            enabled: true,
             title: { en: "Commands", pt: "Comandos" },
             intro: "Intro",
             footer: "Footer",
             cmd: "menu",
             aliases: ["help", "?"],
             notFoundFallback: true,
+            suggestSimilar: false,
+            suggestMaxDistance: 2,
             welcomeMessage: null,
             welcomeWindowDays: 3,
             pageSize: 15,
@@ -134,7 +155,8 @@ missingCmd:
             cmd: "hello",
             aliases: ["hi", "oi"],
             plugin: "sample",
-            function: "greet",
+            functions: ["greet"],
+            loading: null,
             text: "Reply from file",
             desc: { en: "Say hello", pt: "Diga oi" },
             category: "fun",
@@ -150,8 +172,24 @@ missingCmd:
                 cooldownSeconds: 0,
                 whitelist: undefined,
                 blacklist: { groups: undefined, users: ["blocked@c.us"] },
+                dono: undefined,
+                allowedChats: undefined,
+                groupOnly: undefined,
+                dmOnly: undefined,
+                whitelistGroups: undefined,
+                blacklistUsers: undefined,
+                hiddenOutsideScope: undefined,
+            },
+            messages: {
+                botNotAdmin: undefined,
+                senderNotAdmin: undefined,
+                ownerOnly: "Owners only",
+                donoOnly: undefined,
+                wrongScope: undefined,
+                cooldown: undefined,
+                blacklist: undefined,
+                allowedChats: undefined,
             },
-            messages: { botNotAdmin: undefined, senderNotAdmin: undefined, ownerOnly: "Owners only", wrongScope: undefined, cooldown: undefined },
             arguments: [],
             subcommands: [],
         });
@@ -233,4 +271,212 @@ hello:
         assert.equal(config.specs.length, 1);
         assert.equal(config.specs[0].id, "hello");
     });
+    // ── loading: snake_case flat-form props (reference yaml uses these) ──────
+    describe("loading: snake_case flat-form props", () => {
+        test("loading_presets accepts on_success/on_error (reaction) and interval_ms (spinner) — reference yaml's exact shape", async () => {
+            await fs.writeFile(commandsFile, `
+loading_presets:
+  padrao:
+    type: reaction
+    icon: "⏳"
+    on_success: "✅"
+    on_error: "❌"
+  spinner_classico:
+    type: spinner
+    frames: ["⠋", "⠙"]
+    interval_ms: 1000
+    on_success: "✅ Pronto!"
+    on_error: "Erro: {erro}"
+loading: padrao
+`, "utf8");
+            const config = await loadCommandsConfig();
+            assert.ok(config);
+            assert.deepEqual(config.loadingPresets.padrao, {
+                type: "reaction",
+                icon: "⏳",
+                onSuccess: "✅",
+                onError: "❌",
+            });
+            assert.deepEqual(config.loadingPresets.spinner_classico, {
+                type: "spinner",
+                frames: ["⠋", "⠙"],
+                intervalMs: 1000,
+                onSuccess: "✅ Pronto!",
+                onError: "Erro: {erro}",
+            });
+        });
+        test("camelCase and snake_case forms are equivalent, not additive (last one parsed wins, neither is required)", async () => {
+            await fs.writeFile(commandsFile, `
+loading_presets:
+  onlyCamel:
+    type: reaction
+    onSuccess: "camel"
+  onlySnake:
+    type: reaction
+    on_success: "snake"
+`, "utf8");
+            const config = await loadCommandsConfig();
+            assert.ok(config);
+            assert.equal(config.loadingPresets.onlyCamel.onSuccess, "camel");
+            assert.equal(config.loadingPresets.onlySnake.onSuccess, "snake");
+        });
+        test("an actually-unknown property for the declared type is still fatal (malformed config)", async () => {
+            await fs.writeFile(commandsFile, `
+loading_presets:
+  bad:
+    type: reaction
+    frames: ["not", "valid", "for", "reaction"]
+`, "utf8");
+            const config = await loadCommandsConfig();
+            assert.ok(config);
+            assert.equal(config.loadingPresets.bad, undefined, "malformed preset is dropped, not silently accepted");
+        });
+    });
+    // ── top-level `loading:` global default overlays onto defaults.loading ──
+    test("top-level loading: <preset-name> overlays onto defaults.loading, same as notify_*/permission_messages", async () => {
+        await fs.writeFile(commandsFile, `
+loading_presets:
+  padrao:
+    type: reaction
+    icon: "⏳"
+loading: padrao
+`, "utf8");
+        const config = await loadCommandsConfig();
+        assert.ok(config);
+        assert.deepEqual(config.defaults.loading, { type: "reaction", icon: "⏳" });
+    });
+    test("top-level loading: accepts an inline spec, not just a preset name", async () => {
+        await fs.writeFile(commandsFile, `
+loading:
+  type: typing
+`, "utf8");
+        const config = await loadCommandsConfig();
+        assert.ok(config);
+        assert.deepEqual(config.defaults.loading, { type: "typing" });
+    });
+    test("top-level loading: wins over defaults.loading when both are present (overlay semantics)", async () => {
+        await fs.writeFile(commandsFile, `
+defaults:
+  loading:
+    type: typing
+loading:
+  type: none
+`, "utf8");
+        const config = await loadCommandsConfig();
+        assert.ok(config);
+        assert.deepEqual(config.defaults.loading, { type: "none" });
+    });
+    // ── plugin: registry-key normalization ───────────────────────────────
+    // The caller passes the active pluginRegistry's keys via
+    // loadCommandsConfig({ validPluginKeys }). parseEntry uses them to
+    // resolve shorthand `plugin: <name>` entries to the canonical
+    // `owner/repo` key (and to leave fully-qualified entries alone).
+    describe("plugin: registry-key normalization", () => {
+        test("keeps an exact owner/repo key verbatim", async () => {
+            await fs.writeFile(commandsFile, `
+hello:
+  cmd: hello
+  plugin: synt-xerror/welcome
+  functions: [greet]
+`, "utf8");
+            const config = await loadCommandsConfig(new Set(["synt-xerror/welcome", "de/welcome-test"]));
+            assert.ok(config);
+            assert.equal(config.specs.length, 1);
+            assert.equal(config.specs[0].plugin, "synt-xerror/welcome");
+            assert.deepEqual(config.specs[0].functions, ["greet"]);
+        });
+        test("resolves a bare name to the unique matching owner/repo key", async () => {
+            await fs.writeFile(commandsFile, `
+hello:
+  cmd: hello
+  plugin: welcome
+  functions: [greet]
+`, "utf8");
+            const config = await loadCommandsConfig(new Set(["synt-xerror/welcome", "de/welcome-test"]));
+            assert.ok(config);
+            assert.equal(config.specs[0].plugin, "synt-xerror/welcome");
+        });
+        test("splits the inline owner/repo.fn form before normalization", async () => {
+            await fs.writeFile(commandsFile, `
+hello:
+  cmd: hello
+  plugin: synt-xerror/welcome.ping
+`, "utf8");
+            const config = await loadCommandsConfig(new Set(["synt-xerror/welcome", "de/welcome-test"]));
+            assert.ok(config);
+            assert.equal(config.specs[0].plugin, "synt-xerror/welcome");
+            assert.deepEqual(config.specs[0].functions, ["ping"]);
+        });
+        test("splits the inline bare-name.fn form before normalization", async () => {
+            await fs.writeFile(commandsFile, `
+hello:
+  cmd: hello
+  plugin: welcome.ping
+`, "utf8");
+            const config = await loadCommandsConfig(new Set(["synt-xerror/welcome"]));
+            assert.ok(config);
+            assert.equal(config.specs[0].plugin, "synt-xerror/welcome");
+            assert.deepEqual(config.specs[0].functions, ["ping"]);
+        });
+        test("splits core.fn items in functions lists", async () => {
+            await fs.writeFile(commandsFile, `
+hello:
+  cmd: hello
+  functions: [core.greet, core.reply]
+`, "utf8");
+            const config = await loadCommandsConfig(new Set(["core"]));
+            assert.ok(config);
+            assert.equal(config.specs[0].plugin, "core");
+            assert.deepEqual(config.specs[0].functions, ["greet", "reply"]);
+        });
+        test("splits canonical owner/plugin.fn items in subcommands", async () => {
+            await fs.writeFile(commandsFile, `
+figurinha:
+  cmd: f
+  subcommands:
+    - cmd: criar
+      functions: [synt-xerror/figurinha.validarMidia, synt-xerror/figurinha.criarFigurinha]
+`, "utf8");
+            const config = await loadCommandsConfig(new Set(["synt-xerror/figurinha"]));
+            assert.ok(config);
+            assert.equal(config.specs[0].plugin, "synt-xerror/figurinha");
+            assert.deepEqual(config.specs[0].subcommands[0].functions, [
+                "validarMidia",
+                "criarFigurinha",
+            ]);
+        });
+        test("keeps an unknown bare name verbatim (caller surfaces the miss)", async () => {
+            await fs.writeFile(commandsFile, `
+hello:
+  cmd: hello
+  plugin: unknown-plugin
+  functions: [greet]
+`, "utf8");
+            const config = await loadCommandsConfig(new Set(["synt-xerror/welcome", "de/welcome-test"]));
+            assert.ok(config);
+            assert.equal(config.specs[0].plugin, "unknown-plugin");
+        });
+        test("keeps a name verbatim when more than one owner matches (ambiguity surfaces at dispatch)", async () => {
+            await fs.writeFile(commandsFile, `
+hello:
+  cmd: hello
+  plugin: shared
+  functions: [greet]
+`, "utf8");
+            const config = await loadCommandsConfig(new Set(["alice/shared", "bob/shared"]));
+            assert.ok(config);
+            assert.equal(config.specs[0].plugin, "shared");
+        });
+        test("without validPluginKeys the value is used verbatim (legacy path)", async () => {
+            await fs.writeFile(commandsFile, `
+hello:
+  cmd: hello
+  plugin: welcome
+  functions: [greet]
+`, "utf8");
+            const config = await loadCommandsConfig();
+            assert.ok(config);
+            assert.equal(config.specs[0].plugin, "welcome");
+        });
+    });
 });

package/dist/kernel/contactAutoSave.js

@@ -75,10 +75,10 @@ function randomInt(min, max) {
  * failure would be mistaken for a real save and never retried.
  */
 async function addContact(contract, jid, name) {
-    // `jid` here is this framework's internal "@c.us" form (see
-    // getMsgSender()/normalizeJid()) — Baileys needs the real wire JID or
-    // it silently no-ops instead of throwing, which is exactly how this
-    // went unnoticed before.
+    // `jid` here is LID-canonical (see getMsgSender()) — Baileys needs the
+    // real wire JID or it silently no-ops instead of throwing, which is
+    // exactly how this went unnoticed before. toWireJid() passes @lid
+    // through unchanged, so no extra handling is needed here.
     const wireJid = toWireJid(jid);
     try {
         await contract.addOrEditContact(wireJid, {
@@ -101,7 +101,7 @@ async function addContact(contract, jid, name) {
  *
  * @param {WaContract}   contract
  * @param {BotMessage}   msg         — driver-neutral incoming message envelope
- * @param {string}       senderJid   — normalized sender JID (never a group JID)
+ * @param {string|null}  senderJid   — normalized sender JID (LID-canonical; never a group JID), or null when no LID is known yet for this contact — those messages are skipped, since there's no stable id to track progress against
  * @param {boolean}      isGroup     — whether this message came from a group chat
  * @param {boolean}      triggeredBot — true if this message invoked the bot
  *                                     (command prefix). Ignored outside groups.
@@ -109,7 +109,7 @@ async function addContact(contract, jid, name) {
 export async function trackIncomingForContactSave(contract, msg, senderJid, isGroup, triggeredBot) {
     try {
         const pushName = msg.pushName?.trim();
-        if (!pushName || senderJid.endsWith("@g.us"))
+        if (!pushName || !senderJid || senderJid.endsWith("@g.us"))
             return;
         let s = getSenderState(senderJid);
         // Completing a refresh takes priority over new-save logic, but in

package/dist/kernel/coreCommands.js

@@ -0,0 +1,62 @@
+/**
+ * coreCommands.ts
+ *
+ * Built-in command handlers live in the kernel namespace, independently of
+ * the external plugin registry and manyplug configuration.
+ */
+// Mirrors src/locales/*.json — the only languages with a translation file.
+const AVAILABLE_LOCALES = ["pt", "en", "es"];
+const handlers = {
+    ping: async (ctx) => {
+        await ctx.send.text("pong");
+    },
+    status: async (ctx) => {
+        await ctx.send.text("ManyBot está online.");
+    },
+    // `!configurar` / `!config` / `!cfg` (no subcommand) — shows the
+    // current per-chat overrides. Persisted via ctx.settings, which
+    // (per pluginApi.ts) is already scoped to plugin "core" + the
+    // current chat — same storage pattern already used for
+    // last_welcome_seen in commandMenu.ts.
+    setChatConfig: async (ctx) => {
+        const pctx = ctx;
+        const prefix = pctx.settings.get("chat_prefix", null);
+        const locale = pctx.settings.get("chat_locale", null);
+        await pctx.send.text("⚙️ Configuração deste chat:\n" +
+            `• Prefixo: ${prefix ?? "(padrão)"}\n` +
+            `• Idioma: ${locale ?? "(padrão)"}\n\n` +
+            "Use !config prefixo <novo> ou !config idioma <pt|en|es> para alterar.");
+    },
+    // `!config prefixo <novo>`
+    setChatPrefix: async (ctx, input) => {
+        const pctx = ctx;
+        const value = input?.args?.[0];
+        if (!value || value.length > 5) {
+            await pctx.send.text("Uso: !config prefixo <novo prefixo> (até 5 caracteres)");
+            return;
+        }
+        pctx.settings.set("chat_prefix", value);
+        await pctx.send.text(`✅ Prefixo salvo como "${value}" para este chat.\n` +
+            `A partir de agora, use "${value}" em vez do prefixo padrão neste chat.`);
+    },
+    // `!config idioma <pt|en|es>`
+    setChatLocale: async (ctx, input) => {
+        const pctx = ctx;
+        const value = input?.args?.[0]?.toLowerCase();
+        if (!value || !AVAILABLE_LOCALES.includes(value)) {
+            await pctx.send.text(`Uso: !config idioma <${AVAILABLE_LOCALES.join("|")}>`);
+            return;
+        }
+        pctx.settings.set("chat_locale", value);
+        await pctx.send.text(`✅ Idioma salvo como "${value}" para este chat.\n` +
+            "As mensagens do sistema de comandos (menu, permissões, avisos de uso) passam a usar esse idioma neste chat.");
+    },
+};
+export function resolveCoreCommandHandler(name) {
+    return handlers[name] ?? (async () => {
+        throw new Error(`Core handler "${name}" is not registered`);
+    });
+}
+export function registerCoreCommand(name, handler) {
+    handlers[name] = handler;
+}

package/dist/kernel/pluginApi.test.js

@@ -267,7 +267,7 @@ describe("kernel/pluginApi — buildSetupApi with Mock WaContract", () => {
         assert.ok(ctx.chats);
         assert.ok(ctx.contacts);
         assert.ok(ctx.storage);
-        assert.equal(ctx.botId, "5516999999999@s.whatsapp.net");
+        assert.equal(ctx.botId, "99999@lid");
         // Setup send only has .to()
         assert.ok(ctx.send.to);
         assert.equal(typeof ctx.send.to, "function");
@@ -371,13 +371,25 @@ describe("kernel/pluginApi — buildApi (Runtime) with Mock WaContract", () => {
         await ctx.admin.kick("5516777777777@s.whatsapp.net");
         assert.equal(calls.groupParticipantUpdates.length, 2);
         assert.equal(calls.groupParticipantUpdates[1].action, "remove");
+        await assert.rejects(() => ctx.admin.kick("5516999999999@s.whatsapp.net"));
+        assert.equal(calls.groupParticipantUpdates.length, 2);
         const inviteLink = await ctx.admin.getInviteLink();
         assert.match(inviteLink, /chat\.whatsapp\.com\/mock-invite-code-123/);
         // Contacts helper
         const contact = await ctx.contacts.get("5516999999999@s.whatsapp.net");
         assert.ok(contact);
-        assert.equal(contact?.number, "5516999999999");
+        // normalizeContact now returns E.164 (with leading "+") per the
+        // new contract invariant; assert accordingly.
+        assert.equal(contact?.number, "+5516999999999");
         assert.equal(contact?.isMe, true);
+        // Looking up the bot by its own LID (ctx.botId) must resolve the
+        // same identity — number populated via the proactively-learned
+        // LID↔PN mapping, not left null for lack of a resolveLid() hit.
+        const selfByLid = await ctx.contacts.get(ctx.botId);
+        assert.ok(selfByLid);
+        assert.equal(selfByLid?.id, "99999@lid");
+        assert.equal(selfByLid?.number, "+5516999999999");
+        assert.equal(selfByLid?.isMe, true);
         await ctx.contacts.block("5516777777777@s.whatsapp.net");
         assert.equal(calls.blockUpdates.length, 1);
         assert.equal(calls.blockUpdates[0].action, "block");
@@ -578,6 +590,11 @@ describe("kernel/pluginApi — buildApi (Runtime) with Mock WaContract", () => {
         // contacts.get() with a raw @lid routes through contract.resolveLid()
         // (mock: "12345@lid" -> "5516777777777@s.whatsapp.net").
         const contact = await ctx.contacts.get("12345@lid");
-        assert.equal(contact?.id, "5516777777777@c.us");
+        // normalizeContact now keeps the ID as the LID form ("12345@lid")
+        // when known, per the invariant that user IDs are LID-or-null; plugins
+        // should treat contact.id as the canonical JID for addressing and
+        // contact.number/contact.numberRaw as the dialable string.
+        assert.equal(contact?.id, "12345@lid");
+        assert.equal(contact?.number, "+5516777777777");
     });
 });

package/dist/kernel/pluginGuard.js

@@ -38,18 +38,19 @@ function withTimeout(promise, ms, pluginName) {
 }
 export async function runPlugin(plugin, context, handler, input, options) {
     if (plugin.status !== "active")
-        return;
+        return undefined;
     const useTimeout = plugin.guardOptions?.timeout !== false;
     try {
         if (handler) {
             const run = handler(context, input);
-            await (useTimeout ? withTimeout(run, PLUGIN_TIMEOUT_MS, plugin.name) : run);
+            return await (useTimeout ? withTimeout(run, PLUGIN_TIMEOUT_MS, plugin.name) : run);
         }
         else {
             if (!plugin.run)
-                return;
+                return undefined;
             const run = plugin.run(context);
             await (useTimeout ? withTimeout(run, PLUGIN_TIMEOUT_MS, plugin.name) : run);
+            return undefined;
         }
     }
     catch (e) {
@@ -87,5 +88,6 @@ export async function runPlugin(plugin, context, handler, input, options) {
                 });
             });
         }
+        return undefined;
     }
 }

package/dist/kernel/pluginLoader.js

@@ -6,7 +6,7 @@
  *   2. Loading each plugin from ~/.manybot/plugins folder
  *   3. Registering in pluginRegistry with status and public exports
  *   4. Exposing pluginRegistry to kernel and pluginApi
- *   5. Watching plugin files and config file for hot reloading
+ *   5. Watching plugin files, config files and commands.yaml for hot reloading
  */
 import fs from "fs";
 import path from "path";
@@ -33,6 +33,23 @@ const PLUGINS_DIR = path.join(PATHS.HOME, "plugins");
 export const pluginRegistry = new Map();
 let globalContract = null;
 let globalStore = null;
+/**
+ * Live WaContract + BotStore the kernel most-recently wired through
+ * `setupPlugins()`. Exposed for the integration-test harness only
+ * (see `src/plugins/__manybot_integration__/` and the
+ * `*.integration.test.ts` suite under the project root): production
+ * code paths go through `ctx.wa.contract` / `ctx.store`, not through
+ * this module-scoped singleton.
+ *
+ * Returns `null` when the bot hasn't connected yet (or after a
+ * disconnect). The integration suite waits for a non-null value
+ * before issuing any real round-trip.
+ */
+export function getGlobalKernelRefs() {
+    if (!globalContract || !globalStore)
+        return null;
+    return { contract: globalContract, store: globalStore };
+}
 const pluginWatchers = new Map();
 // fs.watch's `recursive: true` emulates recursion on Linux by opening one
 // inotify watch per subdirectory — a plugin shipping its own node_modules
@@ -335,22 +352,68 @@ export function unwatchPlugin(name) {
     }
 }
 /**
- * Watch the config directory for manyplug.toml or manybot.toml changes.
+ * Reload the command registry from disk (commands.yaml + imports).
+ *
+ * Mirrors `reloadPlugin()`: callable on its own and safe to invoke from
+ * a watcher. Unlike `reloadPlugin()` there's no setup retry / disable
+ * state to track — `initCommandRegistry()` either builds a fresh
+ * `CommandRegistry` from the current file content or leaves the
+ * previous one in place via `commandsConfig.ts`'s own error handling
+ * (a malformed YAML logs an error and returns null; `initCommandRegistry`
+ * then falls back to the empty defaults).
+ */
+export async function reloadCommandRegistry() {
+    try {
+        await initCommandRegistry();
+        logger.info(`[watcher] Command registry reloaded from commands.yaml.`);
+    }
+    catch (e) {
+        const err = e instanceof Error ? e : new Error(String(e));
+        logger.error(`[watcher] Failed to reload command registry: ${err.message}`);
+    }
+}
+/**
+ * Watch the config directory for changes to manyplug.toml / manybot.toml
+ * (plugin list sync) or to commands.yaml and its .yaml/.yml imports
+ * (command registry reload). Both paths share the same 500ms debounce
+ * so a save that emits several inotify events only fires once.
  */
 function startConfigWatcher() {
     if (configWatcher)
         return;
+    const isTomlChange = (filename) => filename === "manyplug.toml" || filename === "manybot.toml";
+    const isYamlChange = (filename) => {
+        if (!filename)
+            return false;
+        const lower = filename.toLowerCase();
+        return lower.endsWith(".yaml") || lower.endsWith(".yml");
+    };
     try {
         let configTimeout = null;
+        let yamlTimeout = null;
+        const scheduleTomlReload = (filename) => {
+            if (!isTomlChange(filename))
+                return;
+            if (configTimeout)
+                clearTimeout(configTimeout);
+            configTimeout = setTimeout(async () => {
+                logger.info(`[watcher] Config file change detected: ${filename}. Syncing plugins...`);
+                await syncPlugins();
+            }, 500);
+        };
+        const scheduleYamlReload = (filename) => {
+            if (!isYamlChange(filename))
+                return;
+            if (yamlTimeout)
+                clearTimeout(yamlTimeout);
+            yamlTimeout = setTimeout(async () => {
+                logger.info(`[watcher] commands.yaml change detected (${filename}). Reloading command registry...`);
+                await reloadCommandRegistry();
+            }, 500);
+        };
         configWatcher = fs.watch(PATHS.HOME, (eventType, filename) => {
-            if (filename === "manyplug.toml" || filename === "manybot.toml") {
-                if (configTimeout)
-                    clearTimeout(configTimeout);
-                configTimeout = setTimeout(async () => {
-                    logger.info(`[watcher] Config file change detected: ${filename}. Syncing plugins...`);
-                    await syncPlugins();
-                }, 500);
-            }
+            scheduleTomlReload(filename);
+            scheduleYamlReload(filename);
         });
     }
     catch (e) {