queen-mq 0.1.2 → 0.1.4

package/PROGRAMMATIC_SERVER.md

@@ -0,0 +1,190 @@
+# Queen MQ - Programmatic Server API
+
+As of version 0.1.2, Queen MQ can be run programmatically from your Node.js code, in addition to running it as a standalone process.
+
+## Installation
+
+```bash
+npm install queen-mq
+```
+
+## Basic Usage
+
+### Starting the Server Programmatically
+
+```javascript
+import { QueenServer } from 'queen-mq';
+
+// Start server with default configuration
+const server = await QueenServer();
+
+// Or with custom options
+const server = await QueenServer({
+  port: 3000,
+  host: '127.0.0.1',
+  workerId: 'worker-1'
+});
+
+console.log(`Server running at http://${server.host}:${server.port}`);
+```
+
+### Using Client and Server Together
+
+```javascript
+import { QueenServer, Queen } from 'queen-mq';
+
+// Start the server
+const server = await QueenServer({ port: 3000 });
+
+// Create a client
+const client = new Queen({
+  servers: [`http://localhost:${server.port}`]
+});
+
+// Use the queue
+await client.push({
+  queue: 'my-queue',
+  items: [{ data: { message: 'Hello World' } }]
+});
+
+const result = await client.pop({ queue: 'my-queue' });
+console.log(result.messages);
+```
+
+### Graceful Shutdown
+
+```javascript
+const server = await QueenServer();
+
+// Shutdown programmatically
+await server.shutdown('SIGTERM');
+
+// Or handle process signals
+process.on('SIGINT', async () => {
+  await server.shutdown('SIGINT');
+});
+```
+
+## Server Options
+
+The `QueenServer()` function accepts an options object:
+
+```javascript
+{
+  port: number,        // Server port (default: from config, typically 3000)
+  host: string,        // Server host (default: from config, typically '127.0.0.1')
+  workerId: string     // Worker ID for clustering (default: from config)
+}
+```
+
+## Return Value
+
+The `QueenServer()` function returns a promise that resolves to a server instance with:
+
+```javascript
+{
+  port: number,           // The port the server is listening on
+  host: string,           // The host the server is bound to
+  shutdown: Function,     // Async function to gracefully shutdown the server
+  app: Object            // The underlying uWebSockets.js app instance
+}
+```
+
+## Use Cases
+
+### 1. Embedded Message Queue
+
+Run Queen MQ embedded in your application instead of as a separate service:
+
+```javascript
+import { QueenServer, Queen } from 'queen-mq';
+import express from 'express';
+
+// Start Queen server
+await QueenServer({ port: 3001 });
+
+// Start your application server
+const app = express();
+const client = new Queen({ servers: ['http://localhost:3001'] });
+
+app.post('/api/task', async (req, res) => {
+  await client.push({
+    queue: 'tasks',
+    items: [{ data: req.body }]
+  });
+  res.json({ status: 'queued' });
+});
+
+app.listen(3000);
+```
+
+### 2. Testing
+
+Easily spin up and tear down Queen servers in tests:
+
+```javascript
+import { QueenServer, Queen } from 'queen-mq';
+import { describe, it, beforeAll, afterAll } from 'jest';
+
+describe('Queue Tests', () => {
+  let server, client;
+  
+  beforeAll(async () => {
+    server = await QueenServer({ port: 4000 });
+    client = new Queen({ servers: ['http://localhost:4000'] });
+  });
+  
+  afterAll(async () => {
+    await server.shutdown('TEST');
+  });
+  
+  it('should process messages', async () => {
+    await client.push({
+      queue: 'test-queue',
+      items: [{ data: { test: true } }]
+    });
+    
+    const result = await client.pop({ queue: 'test-queue' });
+    expect(result.messages).toHaveLength(1);
+  });
+});
+```
+
+### 3. Multiple Servers
+
+Run multiple Queen instances in the same process:
+
+```javascript
+import { QueenServer } from 'queen-mq';
+
+// Start multiple servers for different purposes
+const server1 = await QueenServer({ port: 3001, workerId: 'worker-1' });
+const server2 = await QueenServer({ port: 3002, workerId: 'worker-2' });
+
+console.log('Multi-server setup running');
+```
+
+## Traditional Usage
+
+You can still run Queen as a standalone server:
+
+```bash
+npm start
+# or
+node src/server.js
+```
+
+When `src/server.js` is run directly (not imported), it automatically starts the server with configuration from `src/config.js`.
+
+## Requirements
+
+- Node.js ≥ 22.0.0
+- PostgreSQL database (configured via environment variables or config.js)
+- Database must be initialized first (run `npm run init`)
+
+## See Also
+
+- [Main README](./README.md) - General Queen MQ documentation
+- [API Documentation](./API.md) - HTTP API reference
+- [Examples](./examples/) - More usage examples
+

package/README.md

@@ -134,6 +134,33 @@ npm install
 node init-db.js
 ```
 
+### Running the Server
+
+**Option 1: Standalone Server (Traditional)**
+
+```bash
+npm start
+```
+
+**Option 2: Programmatic Server (New in v0.1.2)**
+
+```javascript
+import { QueenServer } from 'queen-mq';
+
+// Start server with default config
+const server = await QueenServer();
+
+// Or with custom options
+const server = await QueenServer({
+  port: 3000,
+  host: '127.0.0.1'
+});
+
+console.log(`Server running at http://${server.host}:${server.port}`);
+```
+
+This allows you to embed Queen MQ directly in your application, run multiple instances, or easily start/stop servers in tests. See [PROGRAMMATIC_SERVER.md](./PROGRAMMATIC_SERVER.md) for more details.
+
 ### Set Environment (Optional)
 
 ```bash

package/examples/batch-processing.js

@@ -14,7 +14,7 @@ for await (const message of q.take('demo-queue', {
   limit: 25,      // Process 25 total
   wait: false 
 })) {
-  console.log(`Message ${++count1}:`, message.payload);
+  console.log(`Message ${++count1}:`, message.data);
   await q.ack(message);
 }
 
@@ -29,7 +29,7 @@ for await (const messages of q.takeBatch('demo-queue', {
   
   // Process entire batch
   for (const msg of messages) {
-    console.log(`  - ${msg.payload}`);
+    console.log(`  - ${msg.data}`);
   }
   
   // Acknowledge entire batch at once

package/examples/programmatic-server.js

@@ -0,0 +1,58 @@
+/**
+ * Example: Starting Queen Server Programmatically
+ * 
+ * This example shows how to import and run the Queen server
+ * directly from your code, rather than running it as a separate process.
+ */
+
+import { QueenServer, Queen } from 'queen-mq';
+
+// Start the server programmatically
+console.log('Starting Queen Server...');
+
+const server = await QueenServer({
+  port: 3000,
+  host: '127.0.0.1'
+});
+
+console.log(`✅ Server started at http://${server.host}:${server.port}`);
+
+// Now you can use the client in the same process
+const client = new Queen({
+  servers: [`http://${server.host}:${server.port}`]
+});
+
+// Create a queue
+await client.push({
+  queue: 'example-queue',
+  items: [
+    { data: { message: 'Hello from programmatic server!' } }
+  ]
+});
+
+console.log('✅ Message pushed to queue');
+
+// Pop a message
+const result = await client.pop({
+  queue: 'example-queue'
+});
+
+console.log('✅ Message received:', result.messages[0]?.data);
+
+// Acknowledge the message
+if (result.messages.length > 0) {
+  await client.ack({
+    transactionId: result.messages[0].transactionId,
+    status: 'completed'
+  });
+  console.log('✅ Message acknowledged');
+}
+
+// Graceful shutdown on SIGINT
+process.on('SIGINT', async () => {
+  console.log('\nShutting down...');
+  await server.shutdown('SIGINT');
+});
+
+console.log('\n📝 Server is running. Press Ctrl+C to stop.');
+

package/examples/test-cache-multi-server.js

@@ -120,7 +120,7 @@ async function testCacheConsistency() {
     log(`Server 1 returned ${pop1.messages?.length || 0} messages`, servers[0]);
     if (pop1.messages && pop1.messages.length > 0) {
       for (const msg of pop1.messages) {
-        log(`  - Message: ${JSON.stringify(msg.payload)}`, servers[0]);
+        log(`  - Message: ${JSON.stringify(msg.data)}`, servers[0]);
         await sessionClient1.ack(msg.transactionId, 'completed');
       }
     }
@@ -140,7 +140,7 @@ async function testCacheConsistency() {
     log(`Server 2 returned ${pop2.messages?.length || 0} messages`, servers[1]);
     if (pop2.messages && pop2.messages.length > 0) {
       for (const msg of pop2.messages) {
-        log(`  - Message: ${JSON.stringify(msg.payload)}`, servers[1]);
+        log(`  - Message: ${JSON.stringify(msg.data)}`, servers[1]);
         await sessionClient2.ack(msg.transactionId, 'completed');
       }
     }

package/examples/test-connection-recovery.js

@@ -0,0 +1,66 @@
+/**
+ * Test connection recovery during take operations
+ * This demonstrates how the client handles server disconnections gracefully
+ */
+
+import { Queen } from '../src/client/index.js';
+
+async function testConnectionRecovery() {
+  const client = new Queen({
+    baseUrl: 'http://localhost:6632',
+    retryDelay: 1000,  // 1 second base retry delay
+    retryAttempts: 3
+  });
+
+  try {
+    // Configure a test queue
+    await client.queue('test-recovery-queue');
+    console.log('Queue configured');
+
+    // Push some test messages
+    await client.push('test-recovery-queue', [
+      { message: 'Test message 1' },
+      { message: 'Test message 2' },
+      { message: 'Test message 3' }
+    ]);
+    console.log('Pushed 3 test messages');
+
+    console.log('\nStarting consumer...');
+    console.log('To test: Stop the server after receiving some messages');
+    console.log('Expected behavior: Client will retry with exponential backoff indefinitely (max 30s between retries)');
+    console.log('                   When server comes back online, it will automatically reconnect\n');
+
+    let messageCount = 0;
+
+    // Consume messages with takeBatch
+    for await (const batch of client.takeBatch('test-recovery-queue', { 
+      batch: 10, 
+      wait: true,
+      timeout: 5000 
+    })) {
+      console.log(`\nReceived batch of ${batch.length} messages:`);
+      
+      for (const message of batch) {
+        messageCount++;
+        console.log(`  ${messageCount}. ${JSON.stringify(message.payload)}`);
+        
+        // Acknowledge the message
+        await client.ack(message, true);
+      }
+    }
+
+    console.log('\nConsumer loop completed');
+    console.log(`Total messages processed: ${messageCount}`);
+
+  } catch (error) {
+    console.error('\nError in consumer:', error.message);
+    console.error('Stack:', error.stack);
+  } finally {
+    await client.close();
+    console.log('\nClient closed');
+  }
+}
+
+console.log('=== Connection Recovery Test ===\n');
+testConnectionRecovery().catch(console.error);
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "queen-mq",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "type": "module",
   "description": "High-performance message queue backed by PostgreSQL",
   "main": "src/client/index.js",

package/src/client/client.js

@@ -234,6 +234,7 @@ export class Queen {
     
     let totalCount = 0;
     let consecutiveEmptyResponses = 0;
+    let consecutiveNetworkErrors = 0;
     const maxConsecutiveEmpty = 3;
     let lastMessageTime = idleTimeout ? Date.now() : null;
     
@@ -304,8 +305,9 @@ export class Queen {
           }
         }
         
-        // Reset empty counter on successful fetch
+        // Reset counters on successful fetch
         consecutiveEmptyResponses = 0;
+        consecutiveNetworkErrors = 0;
         
         // Update last message time if tracking idle timeout
         if (idleTimeout) {
@@ -336,6 +338,30 @@ export class Queen {
           continue;
         }
         
+        // Check if this is a network error (connection refused, socket closed, etc.)
+        const isNetworkError = error.message?.includes('fetch failed') ||
+                              error.message?.includes('ECONNREFUSED') ||
+                              error.message?.includes('ECONNRESET') ||
+                              error.message?.includes('closed') ||
+                              error.cause?.code === 'UND_ERR_SOCKET' ||
+                              error.code === 'ECONNREFUSED' ||
+                              error.code === 'ECONNRESET';
+        
+        if (isNetworkError) {
+          // Log the network error
+          console.warn(`Network error while polling queue: ${error.message}`);
+          
+          // Retry with exponential backoff (capped at 30 seconds)
+          const retryDelay = Math.min(this.#config.retryDelay * Math.pow(2, Math.min(consecutiveNetworkErrors, 10)), 30000);
+          console.warn(`Retrying in ${retryDelay}ms... (attempt ${consecutiveNetworkErrors + 1})`);
+          await new Promise(resolve => setTimeout(resolve, retryDelay));
+          
+          consecutiveNetworkErrors++;
+          
+          // Continue retrying indefinitely
+          continue;
+        }
+        
         // For other errors, throw
         throw error;
       }

package/src/client/index.js

@@ -1,6 +1,7 @@
-// Legacy exports (for backward compatibility)
-export { createQueenClient, createConsumer, createProducer } from './queenClient.js';
 export { LoadBalancingStrategy } from './utils/loadBalancer.js';
 
 // New minimalist interface
-export { Queen, default as default } from './client.js';
+export { Queen } from './client.js';
+
+// Server
+export { QueenServer } from '../server.js';

package/src/managers/queueManagerOptimized.js

@@ -1029,6 +1029,11 @@ export const createOptimizedQueueManager = (pool, resourceCache, eventManager, s
           FROM queen.queues q
           JOIN queen.partitions p ON p.queue_id = q.id
           WHERE q.name = $1 AND p.name = $2
+            AND (q.window_buffer = 0 OR NOT EXISTS (
+              SELECT 1 FROM queen.messages m 
+              WHERE m.partition_id = p.id 
+                AND m.created_at > NOW() - INTERVAL '1 second' * q.window_buffer
+            ))
         `, [queue, partition]);
         
         if (result.rows.length > 0) {
@@ -1037,7 +1042,7 @@ export const createOptimizedQueueManager = (pool, resourceCache, eventManager, s
         }
         
       } else if (accessMode === 'queue') {
-        // CASE 2: Queue-level access - find unlocked partitions
+        // CASE 2: Queue-level access - find unlocked partitions WITH unconsumed messages
         const result = await client.query(`
           SELECT 
             q.id as queue_id,
@@ -1052,13 +1057,27 @@ export const createOptimizedQueueManager = (pool, resourceCache, eventManager, s
             p.name as partition_name
           FROM queen.queues q
           JOIN queen.partitions p ON p.queue_id = q.id
+          LEFT JOIN queen.partition_consumers pc ON pc.partition_id = p.id
+            AND pc.consumer_group = $1
           WHERE q.name = $2
             AND NOT EXISTS (
-              SELECT 1 FROM queen.partition_consumers pc
-              WHERE pc.partition_id = p.id
-                AND pc.consumer_group = $1
-                AND pc.lease_expires_at IS NOT NULL
-                AND pc.lease_expires_at > NOW()
+              SELECT 1 FROM queen.partition_consumers pc2
+              WHERE pc2.partition_id = p.id
+                AND pc2.consumer_group = $1
+                AND pc2.lease_expires_at IS NOT NULL
+                AND pc2.lease_expires_at > NOW()
+            )
+            AND (q.window_buffer = 0 OR NOT EXISTS (
+              SELECT 1 FROM queen.messages m 
+              WHERE m.partition_id = p.id 
+                AND m.created_at > NOW() - INTERVAL '1 second' * q.window_buffer
+            ))
+            AND EXISTS (
+              SELECT 1 FROM queen.messages m2
+              WHERE m2.partition_id = p.id
+                AND m2.id > COALESCE(pc.last_consumed_id, '00000000-0000-0000-0000-000000000000'::uuid)
+                AND (q.delayed_processing = 0 OR m2.created_at <= NOW() - INTERVAL '1 second' * q.delayed_processing)
+                AND (q.max_wait_time_seconds = 0 OR m2.created_at > NOW() - INTERVAL '1 second' * q.max_wait_time_seconds)
             )
           ORDER BY RANDOM()
           LIMIT $3
@@ -1071,29 +1090,23 @@ export const createOptimizedQueueManager = (pool, resourceCache, eventManager, s
         
       } else {
         // CASE 3: Filtered access - namespace/task
+        // Use CTE to first filter partitions by windowBuffer, then find messages
         let filterQuery = `
-          SELECT 
-            q.id as queue_id,
-            q.name as queue_name,
-            q.lease_time,
-            q.retry_limit,
-            q.delayed_processing,
-            q.max_wait_time_seconds,
-            q.window_buffer,
-            q.priority,
-            p.id as partition_id,
-            p.name as partition_name,
-            MIN(m.created_at) as oldest_message
-          FROM queen.messages m
-          JOIN queen.partitions p ON m.partition_id = p.id
-          JOIN queen.queues q ON p.queue_id = q.id
-          LEFT JOIN queen.partition_consumers pc ON p.id = pc.partition_id
-            AND pc.consumer_group = $1
-          WHERE m.id > COALESCE(pc.last_consumed_id, '00000000-0000-0000-0000-000000000000'::uuid)
-            AND (q.delayed_processing = 0 OR m.created_at <= NOW() - INTERVAL '1 second' * q.delayed_processing)
-            AND (q.max_wait_time_seconds = 0 OR 
-                 m.created_at > NOW() - INTERVAL '1 second' * q.max_wait_time_seconds)
-            AND (q.window_buffer = 0 OR NOT EXISTS (
+          WITH eligible_partitions AS (
+            SELECT DISTINCT
+              q.id as queue_id,
+              q.name as queue_name,
+              q.lease_time,
+              q.retry_limit,
+              q.delayed_processing,
+              q.max_wait_time_seconds,
+              q.window_buffer,
+              q.priority,
+              p.id as partition_id,
+              p.name as partition_name
+            FROM queen.queues q
+            JOIN queen.partitions p ON p.queue_id = q.id
+            WHERE (q.window_buffer = 0 OR NOT EXISTS (
               SELECT 1 FROM queen.messages m2 
               WHERE m2.partition_id = p.id 
                 AND m2.created_at > NOW() - INTERVAL '1 second' * q.window_buffer
@@ -1105,27 +1118,44 @@ export const createOptimizedQueueManager = (pool, resourceCache, eventManager, s
                 AND pc2.lease_expires_at IS NOT NULL
                 AND pc2.lease_expires_at > NOW()
             )
+          )
+          SELECT 
+            ep.*,
+            MIN(m.created_at) as oldest_message
+          FROM queen.messages m
+          JOIN eligible_partitions ep ON m.partition_id = ep.partition_id
+          LEFT JOIN queen.partition_consumers pc ON ep.partition_id = pc.partition_id
+            AND pc.consumer_group = $1
+          WHERE m.id > COALESCE(pc.last_consumed_id, '00000000-0000-0000-0000-000000000000'::uuid)
+            AND (ep.delayed_processing = 0 OR m.created_at <= NOW() - INTERVAL '1 second' * ep.delayed_processing)
+            AND (ep.max_wait_time_seconds = 0 OR 
+                 m.created_at > NOW() - INTERVAL '1 second' * ep.max_wait_time_seconds)
         `;
         
         const params = [actualConsumerGroup];
         
+        //Build namespace/task filters for the CTE
+        let cteFilters = '';
         if (namespace) {
           params.push(namespace);
-          filterQuery += ` AND q.namespace = $${params.length}`;
+          cteFilters += ` AND q.namespace = $${params.length}`;
         }
         
         if (task) {
           params.push(task);
-          filterQuery += ` AND q.task = $${params.length}`;
+          cteFilters += ` AND q.task = $${params.length}`;
         }
         
+        // Insert CTE filters before the closing parenthesis
+        filterQuery = filterQuery.replace('            )\n          )', `            )${cteFilters}\n          )`);
+        
         params.push(config.QUEUE.MAX_PARTITION_CANDIDATES);
         filterQuery += `
-          GROUP BY q.id, q.name, q.lease_time, q.retry_limit, q.delayed_processing,
-                   q.max_wait_time_seconds, q.window_buffer, q.priority,
-                   p.id, p.name
+          GROUP BY ep.queue_id, ep.queue_name, ep.lease_time, ep.retry_limit, ep.delayed_processing,
+                   ep.max_wait_time_seconds, ep.window_buffer, ep.priority,
+                   ep.partition_id, ep.partition_name
           HAVING COUNT(*) > 0
-          ORDER BY q.priority DESC, MIN(m.created_at) ASC, RANDOM()
+          ORDER BY ep.priority DESC, MIN(m.created_at) ASC, RANDOM()
           LIMIT $${params.length}
         `;
         
@@ -1344,7 +1374,6 @@ export const createOptimizedQueueManager = (pool, resourceCache, eventManager, s
                   queue: msg.queue_name,
                   partition: msg.partition_name,
                   data: payload,
-                  payload: payload,
                   retryCount: msg.retry_count || 0,
                   priority: msg.priority || 0,
                   createdAt: msg.created_at,

package/src/routes/messages.js

@@ -25,11 +25,11 @@ export const createMessagesRoutes = (pool, queueManager) => {
         pc.last_consumed_id,
         CASE
           WHEN dlq.message_id IS NOT NULL THEN 'dead_letter'
-          WHEN pc.lease_expires_at IS NOT NULL AND pc.lease_expires_at > NOW() THEN 'processing'
           WHEN pc.last_consumed_created_at IS NOT NULL AND (
             m.created_at < pc.last_consumed_created_at OR 
-            (m.created_at = pc.last_consumed_created_at AND m.id <= pc.last_consumed_id)
+            (DATE_TRUNC('milliseconds', m.created_at) = DATE_TRUNC('milliseconds', pc.last_consumed_created_at) AND m.id <= pc.last_consumed_id)
           ) THEN 'completed'
+          WHEN pc.lease_expires_at IS NOT NULL AND pc.lease_expires_at > NOW() THEN 'processing'
           ELSE 'pending'
         END as message_status
       FROM queen.messages m
@@ -64,11 +64,11 @@ export const createMessagesRoutes = (pool, queueManager) => {
       params.push(status);
       query += ` AND CASE
           WHEN dlq.message_id IS NOT NULL THEN 'dead_letter'
-          WHEN pc.lease_expires_at IS NOT NULL AND pc.lease_expires_at > NOW() THEN 'processing'
           WHEN pc.last_consumed_created_at IS NOT NULL AND (
             m.created_at < pc.last_consumed_created_at OR 
-            (m.created_at = pc.last_consumed_created_at AND m.id <= pc.last_consumed_id)
+            (DATE_TRUNC('milliseconds', m.created_at) = DATE_TRUNC('milliseconds', pc.last_consumed_created_at) AND m.id <= pc.last_consumed_id)
           ) THEN 'completed'
+          WHEN pc.lease_expires_at IS NOT NULL AND pc.lease_expires_at > NOW() THEN 'processing'
           ELSE 'pending'
         END = $${++paramCount}`;
     }
@@ -127,11 +127,11 @@ export const createMessagesRoutes = (pool, queueManager) => {
         dlq.retry_count,
         CASE
           WHEN dlq.message_id IS NOT NULL THEN 'dead_letter'
-          WHEN pc.lease_expires_at IS NOT NULL AND pc.lease_expires_at > NOW() THEN 'processing'
           WHEN pc.last_consumed_created_at IS NOT NULL AND (
             m.created_at < pc.last_consumed_created_at OR 
-            (m.created_at = pc.last_consumed_created_at AND m.id <= pc.last_consumed_id)
+            (DATE_TRUNC('milliseconds', m.created_at) = DATE_TRUNC('milliseconds', pc.last_consumed_created_at) AND m.id <= pc.last_consumed_id)
           ) THEN 'completed'
+          WHEN pc.lease_expires_at IS NOT NULL AND pc.lease_expires_at > NOW() THEN 'processing'
           ELSE 'pending'
         END as message_status
       FROM queen.messages m
@@ -284,11 +284,11 @@ export const createMessagesRoutes = (pool, queueManager) => {
         pc.last_consumed_id,
         CASE
           WHEN dlq.message_id IS NOT NULL THEN 'dead_letter'
-          WHEN pc.lease_expires_at IS NOT NULL AND pc.lease_expires_at > NOW() THEN 'processing'
           WHEN pc.last_consumed_created_at IS NOT NULL AND (
             m.created_at < pc.last_consumed_created_at OR 
-            (m.created_at = pc.last_consumed_created_at AND m.id <= pc.last_consumed_id)
+            (DATE_TRUNC('milliseconds', m.created_at) = DATE_TRUNC('milliseconds', pc.last_consumed_created_at) AND m.id <= pc.last_consumed_id)
           ) THEN 'completed'
+          WHEN pc.lease_expires_at IS NOT NULL AND pc.lease_expires_at > NOW() THEN 'processing'
           ELSE 'pending'
         END as message_status
       FROM queen.messages m